From 402907fb58d43e7dce9dca17b091b783b8a0a7e8 Mon Sep 17 00:00:00 2001
From: Pascal Weisenburger <pascal.weisenburger@web.de>
Date: Tue, 7 May 2024 17:00:18 +0200
Subject: [PATCH 001/306] anonymous functions are not macro dependencies

---
 .../dotty/tools/dotc/inlines/Inliner.scala    |  2 ++
 tests/pos-macros/i20353/Macro_1.scala         | 22 +++++++++++++++++++
 tests/pos-macros/i20353/Test_2.scala          | 17 ++++++++++++++
 3 files changed, 41 insertions(+)
 create mode 100644 tests/pos-macros/i20353/Macro_1.scala
 create mode 100644 tests/pos-macros/i20353/Test_2.scala

diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index 7c79e972c126..01b539d04690 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -1104,6 +1104,8 @@ class Inliner(val call: tpd.Tree)(using Context):
     new TreeAccumulator[List[Symbol]] {
       override def apply(syms: List[Symbol], tree: tpd.Tree)(using Context): List[Symbol] =
         tree match {
+          case Closure(env, meth, tpt) if meth.symbol.isAnonymousFunction =>
+            this(syms, tpt :: env)
           case tree: RefTree if tree.isTerm && level == -1 && tree.symbol.isDefinedInCurrentRun && !tree.symbol.isLocal =>
             foldOver(tree.symbol :: syms, tree)
           case _: This if level == -1 && tree.symbol.isDefinedInCurrentRun =>
diff --git a/tests/pos-macros/i20353/Macro_1.scala b/tests/pos-macros/i20353/Macro_1.scala
new file mode 100644
index 000000000000..7f1a914b89c6
--- /dev/null
+++ b/tests/pos-macros/i20353/Macro_1.scala
@@ -0,0 +1,22 @@
+//> using options -experimental -Yno-experimental
+
+import scala.annotation.{experimental, MacroAnnotation}
+import scala.quoted.*
+
+class ImplicitValue
+
+object ImplicitValue:
+  inline given ImplicitValue =
+    ${ makeImplicitValue }
+
+  def makeImplicitValue(using Quotes) =
+    import quotes.reflect.*
+    '{ ImplicitValue() }
+end ImplicitValue
+
+@experimental
+class Test extends MacroAnnotation:
+  def transform(using Quotes)(tree: quotes.reflect.Definition) =
+    import quotes.reflect.*
+    Implicits.search(TypeRepr.of[ImplicitValue])
+    List(tree)
diff --git a/tests/pos-macros/i20353/Test_2.scala b/tests/pos-macros/i20353/Test_2.scala
new file mode 100644
index 000000000000..ebe2bb7af4b3
--- /dev/null
+++ b/tests/pos-macros/i20353/Test_2.scala
@@ -0,0 +1,17 @@
+//> using options -experimental -Yno-experimental
+
+class OuterClass:
+  @Test
+  class InnerClass
+
+  @Test
+  object InnerObject
+end OuterClass
+
+object OuterObject:
+  @Test
+  class InnerClass
+
+  @Test
+  object InnerObject
+end OuterObject

From 9c14610802bb24031401eeca0e7641a0c84cd731 Mon Sep 17 00:00:00 2001
From: Pascal Weisenburger <pascal.weisenburger@web.de>
Date: Tue, 7 May 2024 22:07:01 +0200
Subject: [PATCH 002/306] update for #19677

---
 tests/pos-macros/i20353/Macro_1.scala | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/pos-macros/i20353/Macro_1.scala b/tests/pos-macros/i20353/Macro_1.scala
index 7f1a914b89c6..ba1e1620c1d6 100644
--- a/tests/pos-macros/i20353/Macro_1.scala
+++ b/tests/pos-macros/i20353/Macro_1.scala
@@ -16,7 +16,7 @@ end ImplicitValue
 
 @experimental
 class Test extends MacroAnnotation:
-  def transform(using Quotes)(tree: quotes.reflect.Definition) =
+  def transform(using Quotes)(definition: quotes.reflect.Definition, companion: Option[quotes.reflect.Definition]) =
     import quotes.reflect.*
     Implicits.search(TypeRepr.of[ImplicitValue])
-    List(tree)
+    List(definition)

From ec5cbcc6b93f96755f7b4fa68a86cab845eca2f4 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Thu, 11 Jul 2024 17:34:44 +0200
Subject: [PATCH 003/306] Do not crash when typing a closure with unknown type,
 since it can occur for erroneous input

---
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala | 2 +-
 compiler/src/dotty/tools/dotc/typer/Typer.scala     | 2 --
 tests/neg/i20511-1.scala                            | 7 +++++++
 tests/neg/i20511.scala                              | 8 ++++++++
 4 files changed, 16 insertions(+), 3 deletions(-)
 create mode 100644 tests/neg/i20511-1.scala
 create mode 100644 tests/neg/i20511.scala

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index e28ba5fd669e..ba3f93a42b91 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1725,7 +1725,7 @@ object Parsers {
             case arg =>
               arg
           val args1 = args.mapConserve(sanitize)
-          
+
           if in.isArrow || isPureArrow || erasedArgs.contains(true) then
             functionRest(args)
           else
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index dbc9818abf23..f5f974b33c88 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1977,8 +1977,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
               // Polymorphic SAMs are not currently supported (#6904).
               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)
diff --git a/tests/neg/i20511-1.scala b/tests/neg/i20511-1.scala
new file mode 100644
index 000000000000..03bd475ffafd
--- /dev/null
+++ b/tests/neg/i20511-1.scala
@@ -0,0 +1,7 @@
+package pakiet
+
+def toppingPrice(size: Int): Double = ???
+
+def crustPrice(crustType: Double): Double = ???
+
+export toppingPrice.apply, crustPrice.unlift // error // error // error
diff --git a/tests/neg/i20511.scala b/tests/neg/i20511.scala
new file mode 100644
index 000000000000..657609536bf0
--- /dev/null
+++ b/tests/neg/i20511.scala
@@ -0,0 +1,8 @@
+package pakiet
+
+def toppingPrice(size: Int): Double = ???
+
+def crustPrice(crustType: Double): Double = ???
+
+export toppingPrice, crustPrice // error // error
+val i = 1 // error

From d4d6cec68e0ccab24525a868f9fc9497ec43473c Mon Sep 17 00:00:00 2001
From: kasiaMarek <kasia@marek.net>
Date: Fri, 23 Aug 2024 11:20:58 +0200
Subject: [PATCH 004/306] use new infer expected type for singleton complations

---
 .../dotty/tools/pc/InferExpectedType.scala    |  3 +-
 .../pc/completions/SingletonCompletions.scala | 81 -------------------
 2 files changed, 2 insertions(+), 82 deletions(-)

diff --git a/presentation-compiler/src/main/dotty/tools/pc/InferExpectedType.scala b/presentation-compiler/src/main/dotty/tools/pc/InferExpectedType.scala
index 260a28392093..3d65f69621e1 100644
--- a/presentation-compiler/src/main/dotty/tools/pc/InferExpectedType.scala
+++ b/presentation-compiler/src/main/dotty/tools/pc/InferExpectedType.scala
@@ -7,6 +7,7 @@ import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core.StdNames
 import dotty.tools.dotc.core.Symbols
+import dotty.tools.dotc.core.Symbols.defn
 import dotty.tools.dotc.core.Types.*
 import dotty.tools.dotc.core.Types.Type
 import dotty.tools.dotc.interactive.Interactive
@@ -61,7 +62,7 @@ class InferExpectedType(
 object InterCompletionType:
   def inferType(path: List[Tree])(using Context): Option[Type] =
     path match
-      case (lit: Literal) :: Select(Literal(_), _) :: Apply(Select(Literal(_), _), List(Literal(Constant(null)))) :: rest => inferType(rest, lit.span)
+      case (lit: Literal) :: Select(Literal(_), _) :: Apply(Select(Literal(_), _), List(s: Select)) :: rest if s.symbol == defn.Predef_undefined => inferType(rest, lit.span)
       case ident :: rest => inferType(rest, ident.span)
       case _ => None
 
diff --git a/presentation-compiler/src/main/dotty/tools/pc/completions/SingletonCompletions.scala b/presentation-compiler/src/main/dotty/tools/pc/completions/SingletonCompletions.scala
index 6e59c9afca3a..53c4e01980bc 100644
--- a/presentation-compiler/src/main/dotty/tools/pc/completions/SingletonCompletions.scala
+++ b/presentation-compiler/src/main/dotty/tools/pc/completions/SingletonCompletions.scala
@@ -7,18 +7,13 @@ import dotty.tools.pc.completions.CompletionValue.SingletonValue
 import dotty.tools.dotc.ast.tpd.*
 import dotty.tools.dotc.core.Constants.Constant
 import dotty.tools.dotc.core.Contexts.Context
-import dotty.tools.dotc.core.Flags
-import dotty.tools.dotc.core.StdNames
 import dotty.tools.dotc.core.Symbols
 import dotty.tools.dotc.core.Types.AndType
 import dotty.tools.dotc.core.Types.AppliedType
 import dotty.tools.dotc.core.Types.ConstantType
 import dotty.tools.dotc.core.Types.OrType
-import dotty.tools.dotc.core.Types.TermRef
 import dotty.tools.dotc.core.Types.Type
 import dotty.tools.dotc.core.Types.TypeRef
-import dotty.tools.dotc.util.Spans.Span
-import dotty.tools.dotc.core.Symbols.defn
 
 object SingletonCompletions:
   def contribute(
@@ -55,79 +50,3 @@ object SingletonCompletions:
         collectSingletons(tpe1).intersect(collectSingletons(tpe2))
       case _ => Nil
 
-object InterCompletionType:
-  def inferType(path: List[Tree])(using Context): Option[Type] =
-    path match
-      case (lit: Literal) :: Select(Literal(_), _) :: Apply(Select(Literal(_), _), List(s: Select)) :: rest if s.symbol == defn.Predef_undefined =>
-        inferType(rest, lit.span)
-      case ident :: rest => inferType(rest, ident.span)
-      case _ => None
-
-  def inferType(path: List[Tree], span: Span)(using Context): Option[Type] =
-    path match
-      case Apply(head, List(p : Select)) :: rest if p.name == StdNames.nme.??? && p.qualifier.symbol.name == StdNames.nme.Predef && p.span.isSynthetic =>
-        inferType(rest, span)
-      case Block(_, expr) :: rest if expr.span.contains(span) =>
-        inferType(rest, span)
-      case If(cond, _, _) :: rest if !cond.span.contains(span) =>
-        inferType(rest, span)
-      case Typed(expr, tpt) :: _ if expr.span.contains(span) && !tpt.tpe.isErroneous => Some(tpt.tpe)
-      case Block(_, expr) :: rest if expr.span.contains(span) =>
-        inferType(rest, span)
-      case Bind(_, body) :: rest if body.span.contains(span) => inferType(rest, span)
-      case Alternative(_) :: rest => inferType(rest, span)
-      case Try(block, _, _) :: rest if block.span.contains(span) => inferType(rest, span)
-      case CaseDef(_, _, body) :: Try(_, cases, _) :: rest if body.span.contains(span) && cases.exists(_.span.contains(span)) => inferType(rest, span)
-      case If(cond, _, _) :: rest if !cond.span.contains(span) => inferType(rest, span)
-      case CaseDef(_, _, body) :: Match(_, cases) :: rest if body.span.contains(span) && cases.exists(_.span.contains(span)) =>
-        inferType(rest, span)
-      case NamedArg(_, arg) :: rest if arg.span.contains(span) => inferType(rest, span)
-      // x match
-      //  case @@
-      case CaseDef(pat, _, _) :: Match(sel, cases) :: rest if pat.span.contains(span) && cases.exists(_.span.contains(span)) && !sel.tpe.isErroneous =>
-        sel.tpe match
-          case tpe: TermRef => Some(tpe.symbol.info).filterNot(_.isErroneous)
-          case tpe => Some(tpe)
-      // List(@@)
-      case SeqLiteral(_, tpe) :: _ if !tpe.tpe.isErroneous =>
-        Some(tpe.tpe)
-      // val _: T = @@
-      // def _: T = @@
-      case (defn: ValOrDefDef) :: rest if !defn.tpt.tpe.isErroneous => Some(defn.tpt.tpe)
-      // f(@@)
-      case (app: Apply) :: rest =>
-        val param =
-          for {
-            ind <- app.args.zipWithIndex.collectFirst {
-              case (arg, id) if arg.span.contains(span) => id
-            }
-            params <- app.symbol.paramSymss.find(!_.exists(_.isTypeParam))
-            param <- params.get(ind)
-          } yield param.info
-        param match
-          // def f[T](a: T): T = ???
-          // f[Int](@@)
-          // val _: Int = f(@@)
-          case Some(t : TypeRef) if t.symbol.is(Flags.TypeParam) =>
-            for {
-              (typeParams, args) <-
-                app match
-                  case Apply(TypeApply(fun, args), _) =>
-                    val typeParams = fun.symbol.paramSymss.headOption.filter(_.forall(_.isTypeParam))
-                    typeParams.map((_, args.map(_.tpe)))
-                  // val f: (j: "a") => Int
-                  // f(@@)
-                  case Apply(Select(v, StdNames.nme.apply), _) =>
-                      v.symbol.info match
-                        case AppliedType(des, args) =>
-                          Some((des.typeSymbol.typeParams, args))
-                        case _ => None
-                  case _ => None
-              ind = typeParams.indexOf(t.symbol)
-              tpe <- args.get(ind)
-              if !tpe.isErroneous
-            } yield tpe
-          case Some(tpe) => Some(tpe)
-          case _ => None
-      case _ => None
-

From d02d4b86dfe281cca18760d49f026a2a9b332e53 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 25 Sep 2024 16:43:07 +0100
Subject: [PATCH 005/306] Avoid erasure/preErasure issues around Any in
 transformIsInstanceOf

The testType Any is erased to Object, but the expr type Int isn't erased
to Integer, so then it fails as Int !<: Object.  We avoid the problem by
feeding in AnyVal, leading to a (possibly elided) non-null test only.
---
 .../src/dotty/tools/dotc/transform/TypeTestsCasts.scala     | 6 +++++-
 tests/pos/i21544.scala                                      | 2 ++
 2 files changed, 7 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i21544.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
index 082c239c6443..45596e1d47f6 100644
--- a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
@@ -358,7 +358,11 @@ object TypeTestsCasts {
                 report.error(em"$untestable cannot be used in runtime type tests", tree.srcPos)
                 constant(expr, Literal(Constant(false)))
               case _ =>
-                val erasedTestType = erasure(testType)
+                val erasedTestType =
+                  if testType.isAny && expr.tpe.isPrimitiveValueType then
+                    defn.AnyValType
+                  else
+                    erasure(testType)
                 transformIsInstanceOf(expr, erasedTestType, erasedTestType, flagUnrelated)
         }
 
diff --git a/tests/pos/i21544.scala b/tests/pos/i21544.scala
new file mode 100644
index 000000000000..45da101e7490
--- /dev/null
+++ b/tests/pos/i21544.scala
@@ -0,0 +1,2 @@
+class Test():
+  def m1(xs: List[Boolean]) = for (x: Any) <- xs yield x

From af0283f1c9e3ded09be7b5949755921c82f7c0fd Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 4 Sep 2024 14:09:40 +0100
Subject: [PATCH 006/306] Allow imports nested in packagings to shadow

---
 compiler/src/dotty/tools/dotc/core/ContextOps.scala | 2 +-
 compiler/src/dotty/tools/dotc/typer/Namer.scala     | 2 +-
 tests/pos/i21405.scala                              | 7 +++++++
 3 files changed, 9 insertions(+), 2 deletions(-)
 create mode 100644 tests/pos/i21405.scala

diff --git a/compiler/src/dotty/tools/dotc/core/ContextOps.scala b/compiler/src/dotty/tools/dotc/core/ContextOps.scala
index 57c369a08de6..c307b6ac569e 100644
--- a/compiler/src/dotty/tools/dotc/core/ContextOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/ContextOps.scala
@@ -132,7 +132,7 @@ object ContextOps:
     }
 
     def packageContext(tree: untpd.PackageDef, pkg: Symbol): Context = inContext(ctx) {
-      if (pkg.is(Package)) ctx.fresh.setOwner(pkg.moduleClass).setTree(tree)
+      if (pkg.is(Package)) ctx.fresh.setOwner(pkg.moduleClass).setTree(tree).setNewScope
       else ctx
     }
 end ContextOps
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 6167db62fbe0..5d5d7d1054ea 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -395,7 +395,7 @@ class Namer { typer: Typer =>
     def recur(stat: Tree): Context = stat match {
       case pcl: PackageDef =>
         val pkg = createPackageSymbol(pcl.pid)
-        index(pcl.stats)(using ctx.fresh.setOwner(pkg.moduleClass))
+        index(pcl.stats)(using ctx.packageContext(pcl, pkg))
         invalidateCompanions(pkg, Trees.flatten(pcl.stats map expanded))
         setDocstring(pkg, stat)
         ctx
diff --git a/tests/pos/i21405.scala b/tests/pos/i21405.scala
new file mode 100644
index 000000000000..4fcc1302882b
--- /dev/null
+++ b/tests/pos/i21405.scala
@@ -0,0 +1,7 @@
+package o { class IO }
+package p { class IO }
+import o._
+package q {
+  import p._
+  class D extends IO
+}

From 905cbd147349fcffcd5509850c36ad342dc4fed4 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Thu, 26 Sep 2024 17:13:47 +0100
Subject: [PATCH 007/306] Fix CompletionTest.importAnnotationAfterImport
 expectations

So, before my change, importing java.lang.annotation and then importing
"annotation" will return java.lang.annotation, but complete as
scala.annotation - so the completion logic (in scopeCompletions) is
wrong somewhere.  After my change they both return java.lang.annotation,
so looks like I might have unintentionally made that logic work for this
case - just need to update the test expectation.
---
 .../test/dotty/tools/languageserver/CompletionTest.scala        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/language-server/test/dotty/tools/languageserver/CompletionTest.scala b/language-server/test/dotty/tools/languageserver/CompletionTest.scala
index 8034b4c8d40b..38deb4c40c0f 100644
--- a/language-server/test/dotty/tools/languageserver/CompletionTest.scala
+++ b/language-server/test/dotty/tools/languageserver/CompletionTest.scala
@@ -987,7 +987,7 @@ class CompletionTest {
 
   @Test def importAnnotationAfterImport : Unit =
     code"""import java.lang.annotation; import annot${m1}"""
-      .completion(("annotation", Module, "scala.annotation"))
+      .completion(("annotation", Module, "java.lang.annotation"))
 
   @Test def completeTemplateConstrArgType: Unit = {
     code"""import scala.concurrent.Future

From 6e58d25acd99ff44533730867cfc09873cb95f7a Mon Sep 17 00:00:00 2001
From: Jan Chyb <jan.chyb.99@gmail.com>
Date: Thu, 22 Aug 2024 15:37:26 +0200
Subject: [PATCH 008/306] Avoid using the current denotation in
 NamedType.disambiguate

While recalculating denotation in NamedType we might call
NamedType.disambiguate which uses a denotation to decide about
the correct overloaded method. Using current denotation here might cause
stale symbol errors, so instead we use the lastKnownDenotation,
which should be enough for the use case here, as targetName should not
change between phases/runs.

Later in the denotation recalculation a similar thing happens with
SourceLanguage.apply, where we also now avoid using currentDenotation,
as whether the symbol comes from java or Scala 2 should
also not change between phases/runs.
---
 .../dotty/tools/dotc/core/Denotations.scala   |  2 +-
 .../dotty/tools/dotc/core/TypeErasure.scala   |  9 +++++++--
 .../src/dotty/tools/dotc/core/Types.scala     |  5 ++++-
 tests/pos-macros/i20574/Exports.scala         |  3 +++
 tests/pos-macros/i20574/Macros.scala          | 20 +++++++++++++++++++
 .../pos-macros/i20574/OverloadedInline.scala  | 13 ++++++++++++
 tests/pos-macros/i20574/Test.scala            |  5 +++++
 7 files changed, 53 insertions(+), 4 deletions(-)
 create mode 100644 tests/pos-macros/i20574/Exports.scala
 create mode 100644 tests/pos-macros/i20574/Macros.scala
 create mode 100644 tests/pos-macros/i20574/OverloadedInline.scala
 create mode 100644 tests/pos-macros/i20574/Test.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index 60a7555456bf..816b28177333 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -961,7 +961,7 @@ object Denotations {
     }
 
     def staleSymbolError(using Context): Nothing =
-      if symbol.isPackageObject && ctx.run != null && ctx.run.nn.isCompilingSuspended
+      if symbol.lastKnownDenotation.isPackageObject && ctx.run != null && ctx.run.nn.isCompilingSuspended
       then throw StaleSymbolTypeError(symbol)
       else throw StaleSymbolException(staleSymbolMsg)
 
diff --git a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
index ce4956e6e847..9491bdab9de8 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
@@ -24,11 +24,16 @@ enum SourceLanguage:
 object SourceLanguage:
   /** The language in which `sym` was defined. */
   def apply(sym: Symbol)(using Context): SourceLanguage =
-    if sym.is(JavaDefined) then
+    // We might be using this method while recalculating the denotation,
+    // so let's use `lastKnownDenotation`.
+    // This is ok as the source of the symbol and whether it is inline should
+    // not change between runs/phases.
+    val denot = sym.lastKnownDenotation
+    if denot.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
+    else if denot.isClass && denot.is(Scala2x) || (denot.maybeOwner.lastKnownDenotation.is(Scala2x) && !denot.is(Inline)) then
       SourceLanguage.Scala2
     else
       SourceLanguage.Scala3
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index aba8c3bb31fd..8867f2fbe3db 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -2491,7 +2491,10 @@ object Types extends TypeUtils {
     }
 
     private def disambiguate(d: Denotation)(using Context): Denotation =
-      disambiguate(d, currentSignature, currentSymbol.targetName)
+      // this method might be triggered while the denotation is already being recomputed
+      // in NamedType, so it's better to use lastKnownDenotation instead, as targetName
+      // should not change between phases/runs
+      disambiguate(d, currentSignature, currentSymbol.lastKnownDenotation.targetName)
 
     private def disambiguate(d: Denotation, sig: Signature | Null, target: Name)(using Context): Denotation =
       if (sig != null)
diff --git a/tests/pos-macros/i20574/Exports.scala b/tests/pos-macros/i20574/Exports.scala
new file mode 100644
index 000000000000..328d832fad88
--- /dev/null
+++ b/tests/pos-macros/i20574/Exports.scala
@@ -0,0 +1,3 @@
+object Exports{
+  export OverloadedInline.*
+}
diff --git a/tests/pos-macros/i20574/Macros.scala b/tests/pos-macros/i20574/Macros.scala
new file mode 100644
index 000000000000..a40c1f361ce1
--- /dev/null
+++ b/tests/pos-macros/i20574/Macros.scala
@@ -0,0 +1,20 @@
+import scala.quoted.*
+
+object Macros{
+
+  inline def A() : String = {
+     ${ A_impl }
+  }
+
+  def A_impl(using Quotes): Expr[String] = {
+    Expr("Whatever")
+  }
+
+  inline def B[T]: Int = {
+    ${ B_Impl[T] }
+  }
+
+  def B_Impl[T](using Quotes): Expr[Int] = {
+    Expr(0)
+  }
+}
diff --git a/tests/pos-macros/i20574/OverloadedInline.scala b/tests/pos-macros/i20574/OverloadedInline.scala
new file mode 100644
index 000000000000..5bf2347c45c0
--- /dev/null
+++ b/tests/pos-macros/i20574/OverloadedInline.scala
@@ -0,0 +1,13 @@
+import Macros.*
+
+object OverloadedInline{
+
+    A()
+    inline def overloaded_inline[T]: Unit = {
+        overloaded_inline[T](0)
+    }
+
+    inline def overloaded_inline[T](dummy: Int): Unit = {
+        val crash = B[T]
+    }
+}
diff --git a/tests/pos-macros/i20574/Test.scala b/tests/pos-macros/i20574/Test.scala
new file mode 100644
index 000000000000..abc2b4eb0bc9
--- /dev/null
+++ b/tests/pos-macros/i20574/Test.scala
@@ -0,0 +1,5 @@
+import Exports.*
+
+object Test {
+   overloaded_inline[Unit]
+}

From f931a6d66078f22be8f5820261662efa0074d645 Mon Sep 17 00:00:00 2001
From: Eugene Flesselle <eugene@flesselle.net>
Date: Fri, 4 Oct 2024 18:13:09 +0200
Subject: [PATCH 009/306] Use the NamedTuple type ops for the result types of
 the term ops

---
 .../src-bootstrapped/scala/NamedTuple.scala   | 43 ++++++++-----------
 1 file changed, 18 insertions(+), 25 deletions(-)

diff --git a/library/src-bootstrapped/scala/NamedTuple.scala b/library/src-bootstrapped/scala/NamedTuple.scala
index 71bcd26a16e2..acc318b2be99 100644
--- a/library/src-bootstrapped/scala/NamedTuple.scala
+++ b/library/src-bootstrapped/scala/NamedTuple.scala
@@ -25,6 +25,7 @@ object NamedTuple:
   extension [V <: Tuple](x: V)
     inline def withNames[N <: Tuple]: NamedTuple[N, V] = x
 
+  import NamedTupleDecomposition.{Names, DropNames}
   export NamedTupleDecomposition.{
     Names, DropNames,
     apply, size, init, head, last, tail, take, drop, splitAt, ++, map, reverse, zip, toList, toArray, toIArray
@@ -134,65 +135,57 @@ object NamedTupleDecomposition:
   import NamedTuple.*
   extension [N <: Tuple, V <: Tuple](x: NamedTuple[N, V])
       /** The value (without the name) at index `n` of this tuple */
-    inline def apply(n: Int): Tuple.Elem[V, n.type] =
+    inline def apply(n: Int): Elem[NamedTuple[N, V], n.type] =
       inline x.toTuple match
-        case tup: NonEmptyTuple => tup(n).asInstanceOf[Tuple.Elem[V, n.type]]
-        case tup => tup.productElement(n).asInstanceOf[Tuple.Elem[V, n.type]]
+        case tup: NonEmptyTuple => tup(n).asInstanceOf[Elem[NamedTuple[N, V], n.type]]
+        case tup => tup.productElement(n).asInstanceOf[Elem[NamedTuple[N, V], n.type]]
 
     /** The number of elements in this tuple */
-    inline def size: Tuple.Size[V] = x.toTuple.size
+    inline def size: Size[NamedTuple[N, V]] = x.toTuple.size
 
     /** The first element value of this tuple */
-    inline def head: Tuple.Elem[V, 0] = apply(0)
+    inline def head: Head[NamedTuple[N, V]] = apply(0)
 
     /** The last element value of this tuple */
-    inline def last: Tuple.Last[V] = apply(size - 1).asInstanceOf[Tuple.Last[V]]
+    inline def last: Last[NamedTuple[N, V]] = apply(size - 1).asInstanceOf[Tuple.Last[V]]
 
     /** The tuple consisting of all elements of this tuple except the last one */
-    inline def init: NamedTuple[Tuple.Init[N], Tuple.Init[V]] =
-      x.toTuple.take(size - 1).asInstanceOf[NamedTuple[Tuple.Init[N], Tuple.Init[V]]]
+    inline def init: Init[NamedTuple[N, V]] =
+      x.toTuple.take(size - 1).asInstanceOf[Init[NamedTuple[N, V]]]
 
     /** The tuple consisting of all elements of this tuple except the first one */
-    inline def tail: NamedTuple[Tuple.Tail[N], Tuple.Tail[V]] =
-      x.toTuple.drop(1).asInstanceOf[NamedTuple[Tuple.Tail[N], Tuple.Tail[V]]]
+    inline def tail: Tail[NamedTuple[N, V]] =
+      x.toTuple.drop(1).asInstanceOf[Tail[NamedTuple[N, V]]]
 
     /** The tuple consisting of the first `n` elements of this tuple, or all
      *  elements if `n` exceeds `size`.
      */
-    inline def take(n: Int): NamedTuple[Tuple.Take[N, n.type], Tuple.Take[V, n.type]] =
-      x.toTuple.take(n)
+    inline def take(n: Int): Take[NamedTuple[N, V], n.type] = x.toTuple.take(n)
 
     /** The tuple consisting of all elements of this tuple except the first `n` ones,
      *  or no elements if `n` exceeds `size`.
      */
-    inline def drop(n: Int): NamedTuple[Tuple.Drop[N, n.type], Tuple.Drop[V, n.type]] =
-      x.toTuple.drop(n)
+    inline def drop(n: Int): Drop[NamedTuple[N, V], n.type] = x.toTuple.drop(n)
 
     /** The tuple `(x.take(n), x.drop(n))` */
-    inline def splitAt(n: Int):
-      (NamedTuple[Tuple.Take[N, n.type], Tuple.Take[V, n.type]],
-       NamedTuple[Tuple.Drop[N, n.type], Tuple.Drop[V, n.type]]) =
-        // would be nice if this could have type `Split[NamedTuple[N, V]]` instead, but
-        // we get a type error then. Similar for other methods here.
-      x.toTuple.splitAt(n)
+    inline def splitAt(n: Int): Split[NamedTuple[N, V], n.type] = x.toTuple.splitAt(n)
 
     /** The tuple consisting of all elements of this tuple followed by all elements
      *  of tuple `that`. The names of the two tuples must be disjoint.
      */
     inline def ++ [N2 <: Tuple, V2 <: Tuple](that: NamedTuple[N2, V2])(using Tuple.Disjoint[N, N2] =:= true)
-      : NamedTuple[Tuple.Concat[N, N2], Tuple.Concat[V, V2]]
+      : Concat[NamedTuple[N, V], NamedTuple[N2, V2]]
       = x.toTuple ++ that.toTuple
 
     /** The named tuple consisting of all element values of this tuple mapped by
      *  the polymorphic mapping function `f`. The names of elements are preserved.
      *  If `x = (n1 = v1, ..., ni = vi)` then `x.map(f) = `(n1 = f(v1), ..., ni = f(vi))`.
      */
-    inline def map[F[_]](f: [t] => t => F[t]): NamedTuple[N, Tuple.Map[V, F]] =
+    inline def map[F[_]](f: [t] => t => F[t]): Map[NamedTuple[N, V], F] =
       x.toTuple.map(f).asInstanceOf[NamedTuple[N, Tuple.Map[V, F]]]
 
     /** The named tuple consisting of all elements of this tuple in reverse */
-    inline def reverse: NamedTuple[Tuple.Reverse[N], Tuple.Reverse[V]] =
-      x.toTuple.reverse
+    inline def reverse: Reverse[NamedTuple[N, V]] = x.toTuple.reverse
 
     /** The named tuple consisting of all elements values of this tuple zipped
      *  with corresponding element values in named tuple `that`.
@@ -201,7 +194,7 @@ object NamedTupleDecomposition:
      *  The names of `x` and `that` at the same index must be the same.
      *  The result tuple keeps the same names as the operand tuples.
      */
-    inline def zip[V2 <: Tuple](that: NamedTuple[N, V2]): NamedTuple[N, Tuple.Zip[V, V2]] =
+    inline def zip[V2 <: Tuple](that: NamedTuple[N, V2]): Zip[NamedTuple[N, V], NamedTuple[N, V2]] =
       x.toTuple.zip(that.toTuple)
 
     /** A list consisting of all element values */

From 12eb487179949815102d5a194ac25f5e7c26d0af Mon Sep 17 00:00:00 2001
From: Eugene Flesselle <eugene@flesselle.net>
Date: Fri, 4 Oct 2024 18:34:19 +0200
Subject: [PATCH 010/306] Drop `asInstanceOf` from the NamedTuple term ops
 where possible

---
 library/src-bootstrapped/scala/NamedTuple.scala | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/library/src-bootstrapped/scala/NamedTuple.scala b/library/src-bootstrapped/scala/NamedTuple.scala
index acc318b2be99..37ce031fba10 100644
--- a/library/src-bootstrapped/scala/NamedTuple.scala
+++ b/library/src-bootstrapped/scala/NamedTuple.scala
@@ -147,15 +147,14 @@ object NamedTupleDecomposition:
     inline def head: Head[NamedTuple[N, V]] = apply(0)
 
     /** The last element value of this tuple */
-    inline def last: Last[NamedTuple[N, V]] = apply(size - 1).asInstanceOf[Tuple.Last[V]]
+    inline def last: Last[NamedTuple[N, V]] = apply(size - 1).asInstanceOf[Last[NamedTuple[N, V]]]
 
     /** The tuple consisting of all elements of this tuple except the last one */
     inline def init: Init[NamedTuple[N, V]] =
-      x.toTuple.take(size - 1).asInstanceOf[Init[NamedTuple[N, V]]]
+      x.take(size - 1).asInstanceOf[Init[NamedTuple[N, V]]]
 
     /** The tuple consisting of all elements of this tuple except the first one */
-    inline def tail: Tail[NamedTuple[N, V]] =
-      x.toTuple.drop(1).asInstanceOf[Tail[NamedTuple[N, V]]]
+    inline def tail: Tail[NamedTuple[N, V]] = x.toTuple.drop(1)
 
     /** The tuple consisting of the first `n` elements of this tuple, or all
      *  elements if `n` exceeds `size`.
@@ -182,7 +181,7 @@ object NamedTupleDecomposition:
      *  If `x = (n1 = v1, ..., ni = vi)` then `x.map(f) = `(n1 = f(v1), ..., ni = f(vi))`.
      */
     inline def map[F[_]](f: [t] => t => F[t]): Map[NamedTuple[N, V], F] =
-      x.toTuple.map(f).asInstanceOf[NamedTuple[N, Tuple.Map[V, F]]]
+      x.toTuple.map(f)
 
     /** The named tuple consisting of all elements of this tuple in reverse */
     inline def reverse: Reverse[NamedTuple[N, V]] = x.toTuple.reverse
@@ -198,7 +197,7 @@ object NamedTupleDecomposition:
       x.toTuple.zip(that.toTuple)
 
     /** A list consisting of all element values */
-    inline def toList: List[Tuple.Union[V]] = x.toTuple.toList.asInstanceOf[List[Tuple.Union[V]]]
+    inline def toList: List[Tuple.Union[V]] = x.toTuple.toList
 
     /** An array consisting of all element values */
     inline def toArray: Array[Object] = x.toTuple.toArray

From 6a971b1eec85f887652482b492ad169c0e98a586 Mon Sep 17 00:00:00 2001
From: Eugene Flesselle <eugene@flesselle.net>
Date: Fri, 4 Oct 2024 19:06:17 +0200
Subject: [PATCH 011/306] Fix typos

---
 docs/_docs/reference/other-new-features/named-tuples.md | 4 ++--
 library/src-bootstrapped/scala/NamedTuple.scala         | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/_docs/reference/other-new-features/named-tuples.md b/docs/_docs/reference/other-new-features/named-tuples.md
index bf1ae4ca7046..0abc91e5ecf8 100644
--- a/docs/_docs/reference/other-new-features/named-tuples.md
+++ b/docs/_docs/reference/other-new-features/named-tuples.md
@@ -127,7 +127,7 @@ NamedTuple[("name", "age"), (String, Int)]
 
 A `NamedTuple[N, V]` type is publicly known to be a supertype (but not a subtype) of its value paramater `V`, which means that regular tuples can be assigned to named tuples but not _vice versa_.
 
-The `NamedTuple` object contains a number of extension methods for named tuples hat mirror the same functions in `Tuple`. Examples are
+The `NamedTuple` object contains a number of extension methods for named tuples that mirror the same functions in `Tuple`. Examples are
 `apply`, `head`, `tail`, `take`, `drop`, `++`, `map`, or `zip`.
 Similar to `Tuple`, the `NamedTuple` object also contains types such as `Elem`, `Head`, `Concat`
 that describe the results of these extension methods.
@@ -154,7 +154,7 @@ that `c: C`, and that `n` is not otherwise legal as a name of a selection on `c`
 Then `c.n` is a legal selection, which expands to `c.selectDynamic("n").asInstanceOf[T]`.
 
 It is the task of the implementation of `selectDynamic` in `C` to ensure that its
-computed result conforms to the predicted type `T`
+computed result conforms to the predicted type `T`.
 
 As an example, assume we have a query type `Q[T]` defined as follows:
 
diff --git a/library/src-bootstrapped/scala/NamedTuple.scala b/library/src-bootstrapped/scala/NamedTuple.scala
index 37ce031fba10..f8a821dc45ef 100644
--- a/library/src-bootstrapped/scala/NamedTuple.scala
+++ b/library/src-bootstrapped/scala/NamedTuple.scala
@@ -186,7 +186,7 @@ object NamedTupleDecomposition:
     /** The named tuple consisting of all elements of this tuple in reverse */
     inline def reverse: Reverse[NamedTuple[N, V]] = x.toTuple.reverse
 
-    /** The named tuple consisting of all elements values of this tuple zipped
+    /** The named tuple consisting of all element values of this tuple zipped
      *  with corresponding element values in named tuple `that`.
      *  If the two tuples have different sizes,
      *  the extra elements of the larger tuple will be disregarded.

From 127bb7bf5c24dbcac780d3f5c5bc7ef1ca1821e5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= <sjrdoeraene@gmail.com>
Date: Fri, 4 Oct 2024 17:27:07 +0200
Subject: [PATCH 012/306] Fix #20271: Bring for comprehension spec up to date.

Since Scala 3.4, a `withFilter` is generated if and only if the
generator has the `case` modifier.

If it does not, the pattern must be irrefutable.
---
 docs/_spec/06-expressions.md | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/docs/_spec/06-expressions.md b/docs/_spec/06-expressions.md
index 5043e752ebe6..a633c30e0e4b 100644
--- a/docs/_spec/06-expressions.md
+++ b/docs/_spec/06-expressions.md
@@ -729,8 +729,9 @@ A _for loop_ `for (´\mathit{enums}\,´) ´e´` executes expression ´e´ for ea
 A _for comprehension_ `for (´\mathit{enums}\,´) yield ´e´` evaluates expression ´e´ for each binding generated by the enumerators ´\mathit{enums}´ and collects the results.
 An enumerator sequence always starts with a generator; this can be followed by further generators, value definitions, or guards.
 
-A _generator_ `´p´ <- ´e´` produces bindings from an expression ´e´ which is matched in some way against pattern ´p´.
-Optionally, `case` can appear in front of a generator pattern, this has no meaning in Scala 2 but will be [required in Scala 3 if `p` is not irrefutable](https://docs.scala-lang.org/scala3/reference/changed-features/pattern-bindings.html).
+A _generator_ `´p´ <- ´e´` produces bindings from an expression ´e´ which is deconstructed by the pattern ´p´.
+The pattern must be [irrefutable](08-pattern-matching.html#irrefutable-patterns).
+A _conditional generator_ `case ´p´ <- ´e´` tests whether elements produced by ´e´ match the pattern and discards the ones that do not match.
 
 A _value definition_ `´p´ = ´e´` binds the value name ´p´ (or several names in a pattern ´p´) to the result of evaluating the expression ´e´.
 A _guard_ `if ´e´` contains a boolean expression which restricts enumerated bindings.
@@ -738,7 +739,7 @@ The precise meaning of generators and guards is defined by translation to invoca
 These methods can be implemented in different ways for different carrier types.
 
 The translation scheme is as follows.
-In a first step, every generator `´p´ <- ´e´`, where ´p´ is not [irrefutable](08-pattern-matching.html#patterns) for the type of ´e´ is replaced by
+In a first step, every generator `case ´p´ <- ´e´` is replaced by
 
 ```scala
 ´p´ <- ´e´.withFilter { case ´p´ => true; case _ => false }
@@ -772,7 +773,7 @@ Then, the following rules are applied repeatedly until all comprehensions have b
     ´e´.foreach { case ´p´ => for (´p'´ <- ´e'; ...´) ´e''´ }
     ```
 
-  - A generator `´p´ <- ´e´` followed by a guard `if ´g´` is translated to a single generator `´p´ <- ´e´.withFilter((´x_1, ..., x_n´) => ´g\,´)` where ´x_1, ..., x_n´ are the free variables of ´p´.
+  - A generator `´p´ <- ´e´` followed by a guard `if ´g´` is translated to a single generator `´p´ <- ´e´.withFilter({ case ´p´ => ´g\,´ })`.
 
   - A generator `´p´ <- ´e´` followed by a value definition `´p'´ = ´e'´` is translated to the following generator of pairs of values, where ´x´ and ´x'´ are fresh names:
 

From 8258bb0e327a4c2fabaac23e39c3c860e0fb4038 Mon Sep 17 00:00:00 2001
From: Hamza Remmal <hamza@remmal.dev>
Date: Tue, 8 Oct 2024 15:57:11 +0200
Subject: [PATCH 013/306] Drop support for old experimental in community-build

---
 .../communitybuild/CommunityBuildRunner.scala   | 13 ++++++-------
 .../src/scala/dotty/communitybuild/Main.scala   |  5 +----
 .../scala/dotty/communitybuild/projects.scala   | 17 ++---------------
 3 files changed, 9 insertions(+), 26 deletions(-)

diff --git a/community-build/src/scala/dotty/communitybuild/CommunityBuildRunner.scala b/community-build/src/scala/dotty/communitybuild/CommunityBuildRunner.scala
index 6a0c54c4b00b..b3065fefe87f 100644
--- a/community-build/src/scala/dotty/communitybuild/CommunityBuildRunner.scala
+++ b/community-build/src/scala/dotty/communitybuild/CommunityBuildRunner.scala
@@ -16,13 +16,12 @@ object CommunityBuildRunner:
    *  and avoid network overhead. See https://github.com/lampepfl/dotty-drone
    *  for more infrastructural details.
    */
-  extension (self: CommunityProject) def run()(using suite: CommunityBuildRunner): Unit =
-    if self.requiresExperimental && !compilerSupportExperimental then
-      log(s"Skipping ${self.project} - it needs experimental features unsupported in this build.")
-      return
-    self.dependencies.foreach(_.publish())
-    self.testOnlyDependencies().foreach(_.publish())
-    suite.runProject(self)
+  extension (self: CommunityProject) 
+    def run()(using suite: CommunityBuildRunner): Unit =
+      self.dependencies.foreach(_.publish())
+      self.testOnlyDependencies().foreach(_.publish())
+      suite.runProject(self)
+  end extension
 
 trait CommunityBuildRunner:
 
diff --git a/community-build/src/scala/dotty/communitybuild/Main.scala b/community-build/src/scala/dotty/communitybuild/Main.scala
index 852cee46af22..c813f5ff684b 100644
--- a/community-build/src/scala/dotty/communitybuild/Main.scala
+++ b/community-build/src/scala/dotty/communitybuild/Main.scala
@@ -55,10 +55,7 @@ object Main:
         Seq("rm", "-rf", destStr).!
         Files.createDirectory(dest)
         val (toRun, ignored) =
-          allProjects.partition( p =>
-            p.docCommand != null
-            && (!p.requiresExperimental || compilerSupportExperimental)
-          )
+          allProjects.partition(_.docCommand != null)
 
         val paths = toRun.map { project =>
           val name = project.project
diff --git a/community-build/src/scala/dotty/communitybuild/projects.scala b/community-build/src/scala/dotty/communitybuild/projects.scala
index a0444505801a..e8d6c3d2894d 100644
--- a/community-build/src/scala/dotty/communitybuild/projects.scala
+++ b/community-build/src/scala/dotty/communitybuild/projects.scala
@@ -10,9 +10,6 @@ lazy val compilerVersion: String =
   val file = communitybuildDir.resolve("scala3-bootstrapped.version")
   new String(Files.readAllBytes(file), UTF_8)
 
-lazy val compilerSupportExperimental: Boolean =
-  compilerVersion.contains("SNAPSHOT") || compilerVersion.contains("NIGHTLY")
-
 lazy val sbtPluginFilePath: String =
   // Workaround for https://github.com/sbt/sbt/issues/4395
   new File(sys.props("user.home") + "/.sbt/1.0/plugins").mkdirs()
@@ -43,7 +40,6 @@ sealed trait CommunityProject:
   val testOnlyDependencies: () => List[CommunityProject]
   val binaryName: String
   val runCommandsArgs: List[String] = Nil
-  val requiresExperimental: Boolean
   val environment: Map[String, String] = Map.empty
 
   final val projectDir = communitybuildDir.resolve("community-projects").resolve(project)
@@ -53,7 +49,6 @@ sealed trait CommunityProject:
 
   /** Publish this project to the local Maven repository */
   final def publish(): Unit =
-    // TODO what should this do with .requiresExperimental?
     if !published then
       publishDependencies()
       log(s"Publishing $project")
@@ -65,11 +60,6 @@ sealed trait CommunityProject:
       published = true
 
   final def doc(): Unit =
-    if this.requiresExperimental && !compilerSupportExperimental then
-      log(
-        s"Skipping ${this.project} - it needs experimental features unsupported in this build."
-      )
-      return
     publishDependencies()
     log(s"Documenting $project")
     if docCommand eq null then
@@ -89,8 +79,7 @@ final case class MillCommunityProject(
     baseCommand: String,
     dependencies: List[CommunityProject] = Nil,
     testOnlyDependencies: () => List[CommunityProject] = () => Nil,
-    ignoreDocs: Boolean = false,
-    requiresExperimental: Boolean = false,
+    ignoreDocs: Boolean = false
     ) extends CommunityProject:
   override val binaryName: String = "./mill"
   override val testCommand = s"$baseCommand.test"
@@ -109,8 +98,7 @@ final case class SbtCommunityProject(
     testOnlyDependencies: () => List[CommunityProject] = () => Nil,
     sbtPublishCommand: String = null,
     sbtDocCommand: String = null,
-    scalacOptions: List[String] = SbtCommunityProject.scalacOptions,
-    requiresExperimental: Boolean = false,
+    scalacOptions: List[String] = SbtCommunityProject.scalacOptions
   ) extends CommunityProject:
   override val binaryName: String = "sbt"
 
@@ -260,7 +248,6 @@ object projects:
     project       = "intent",
     sbtTestCommand   = "test",
     sbtDocCommand = "doc",
-    requiresExperimental = true,
   )
 
   lazy val scalacheck = SbtCommunityProject(

From bd88a0f510a7c4c910e33bee2bf2ca8626ff78ea Mon Sep 17 00:00:00 2001
From: Eugene Flesselle <eugene@flesselle.net>
Date: Wed, 9 Oct 2024 17:03:47 +0200
Subject: [PATCH 014/306] Add an explicit type instantiation in
 `NamedTuple.map`

To avoid triggering a deep subtype comparison
needed for the inference of the higher-kinded type parameter.
---
 library/src-bootstrapped/scala/NamedTuple.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/src-bootstrapped/scala/NamedTuple.scala b/library/src-bootstrapped/scala/NamedTuple.scala
index f8a821dc45ef..d105cf042f37 100644
--- a/library/src-bootstrapped/scala/NamedTuple.scala
+++ b/library/src-bootstrapped/scala/NamedTuple.scala
@@ -181,7 +181,7 @@ object NamedTupleDecomposition:
      *  If `x = (n1 = v1, ..., ni = vi)` then `x.map(f) = `(n1 = f(v1), ..., ni = f(vi))`.
      */
     inline def map[F[_]](f: [t] => t => F[t]): Map[NamedTuple[N, V], F] =
-      x.toTuple.map(f)
+      x.toTuple.map[F](f)
 
     /** The named tuple consisting of all elements of this tuple in reverse */
     inline def reverse: Reverse[NamedTuple[N, V]] = x.toTuple.reverse

From 632278e9c78a3bd4067d8caf649d8d07fd96f2b9 Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Mon, 25 Dec 2023 15:27:28 -0800
Subject: [PATCH 015/306] Flag class file collision as error

---
 compiler/src/dotty/tools/backend/jvm/PostProcessor.scala | 2 +-
 tests/pos-with-compiler-cc/backend/jvm/GenBCode.scala    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/backend/jvm/PostProcessor.scala b/compiler/src/dotty/tools/backend/jvm/PostProcessor.scala
index 06c3c7f1cb4f..9f172806a3b5 100644
--- a/compiler/src/dotty/tools/backend/jvm/PostProcessor.scala
+++ b/compiler/src/dotty/tools/backend/jvm/PostProcessor.scala
@@ -73,7 +73,7 @@ class PostProcessor(val frontendAccess: PostProcessorFrontendAccess, val bTypes:
           else s" (defined in ${pos2.source.file.name})"
         def nicify(name: String): String = name.replace('/', '.').nn
         if name1 == name2 then
-          backendReporting.warning(
+          backendReporting.error(
             em"${nicify(name1)} and ${nicify(name2)} produce classes that overwrite one another", pos1)
         else
           backendReporting.warning(
diff --git a/tests/pos-with-compiler-cc/backend/jvm/GenBCode.scala b/tests/pos-with-compiler-cc/backend/jvm/GenBCode.scala
index 1af7e5dd705a..3bc9fb5592ee 100644
--- a/tests/pos-with-compiler-cc/backend/jvm/GenBCode.scala
+++ b/tests/pos-with-compiler-cc/backend/jvm/GenBCode.scala
@@ -214,7 +214,7 @@ class GenBCodePipeline(val int: DottyBackendInterface, val primitives: DottyPrim
           val same = classSymbol.effectiveName.toString == dupClassSym.effectiveName.toString
           atPhase(typerPhase) {
             if (same)
-              report.warning( // FIXME: This should really be an error, but then FromTasty tests fail
+              report.error(
                 em"$cl1 and ${cl2.showLocated} produce classes that overwrite one another", cl1.sourcePos)
             else
               report.warning(

From ac05bd5950ac9af26533930ef1d88724aca95f99 Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Wed, 9 Oct 2024 11:57:15 -0700
Subject: [PATCH 016/306] Add test case neg/i19248

---
 tests/neg/i19248/Foo.scala   | 7 +++++++
 tests/neg/i19248/Main.scala  | 3 +++
 tests/neg/i19248/Scope.scala | 4 ++++
 tests/neg/i19248/empty.scala | 1 +
 4 files changed, 15 insertions(+)
 create mode 100644 tests/neg/i19248/Foo.scala
 create mode 100644 tests/neg/i19248/Main.scala
 create mode 100644 tests/neg/i19248/Scope.scala
 create mode 100644 tests/neg/i19248/empty.scala

diff --git a/tests/neg/i19248/Foo.scala b/tests/neg/i19248/Foo.scala
new file mode 100644
index 000000000000..f24651234eb9
--- /dev/null
+++ b/tests/neg/i19248/Foo.scala
@@ -0,0 +1,7 @@
+trait Foo { // error
+  class Bar
+
+  type T = Foo.this.Bar
+
+  inline def f: Int = ???
+}
diff --git a/tests/neg/i19248/Main.scala b/tests/neg/i19248/Main.scala
new file mode 100644
index 000000000000..bf4e3a48b279
--- /dev/null
+++ b/tests/neg/i19248/Main.scala
@@ -0,0 +1,3 @@
+@main
+def Main(args: String*): Unit =
+  ()
diff --git a/tests/neg/i19248/Scope.scala b/tests/neg/i19248/Scope.scala
new file mode 100644
index 000000000000..a3135d93084f
--- /dev/null
+++ b/tests/neg/i19248/Scope.scala
@@ -0,0 +1,4 @@
+object Scope {
+}
+object Foo {
+}
diff --git a/tests/neg/i19248/empty.scala b/tests/neg/i19248/empty.scala
new file mode 100644
index 000000000000..8b137891791f
--- /dev/null
+++ b/tests/neg/i19248/empty.scala
@@ -0,0 +1 @@
+

From 41e8a126443e85bebfc8e9de84fb7949e845f981 Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Wed, 9 Oct 2024 15:40:43 -0700
Subject: [PATCH 017/306] Reclassify main-functions-nameclash test

---
 tests/neg/main-functions-nameclash.scala  | 3 +++
 tests/warn/main-functions-nameclash.scala | 5 -----
 2 files changed, 3 insertions(+), 5 deletions(-)
 create mode 100644 tests/neg/main-functions-nameclash.scala
 delete mode 100644 tests/warn/main-functions-nameclash.scala

diff --git a/tests/neg/main-functions-nameclash.scala b/tests/neg/main-functions-nameclash.scala
new file mode 100644
index 000000000000..23a530e28271
--- /dev/null
+++ b/tests/neg/main-functions-nameclash.scala
@@ -0,0 +1,3 @@
+object foo {
+  @main def foo(x: Int) = () // error: class foo and object foo produce classes that overwrite one another
+}
diff --git a/tests/warn/main-functions-nameclash.scala b/tests/warn/main-functions-nameclash.scala
deleted file mode 100644
index bc0fe64379d4..000000000000
--- a/tests/warn/main-functions-nameclash.scala
+++ /dev/null
@@ -1,5 +0,0 @@
-
-
-object foo {
-  @main def foo(x: Int) = () // warn: class foo and object foo produce classes that overwrite one another
-}

From 69f5f730c9b887ccaf8436729de2a2f52fed871c Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Thu, 10 Oct 2024 12:43:42 +0100
Subject: [PATCH 018/306] Fix ctx implicits under case unapplySeq

A case class with a varargs has a unapplySeq extractor instead of
unapply.  When we type an unapply, in typedUnapply, we first look for
unapply methods before unapplySeq methods.  But when searching for
unapply, if a class method isn't found, then an extension method is
looked for, which causes context implicits to be cached.  The bindings
from a pattern (such as from an unapply or unapplySeq extractor) are
added to the context in indexPattern.  But Context's `implicitCache`
doesn't account for the scope changing.

I opted for giving the body its own scope context, rather than making
indexPattern reset the context implicits cache.
---
 compiler/src/dotty/tools/dotc/typer/Typer.scala | 4 ++--
 tests/pos/i21742.1.scala                        | 5 +++++
 tests/pos/i21742.2.scala                        | 5 +++++
 3 files changed, 12 insertions(+), 2 deletions(-)
 create mode 100644 tests/pos/i21742.1.scala
 create mode 100644 tests/pos/i21742.2.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index f20c2d313ec7..ed0ff5e0bd2f 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2198,7 +2198,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   /** 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
+    val gadtCtx: Context = ctx.fresh.setFreshGADTBounds
 
     def caseRest(pat: Tree)(using Context) = {
       val pt1 = instantiateMatchTypeProto(pat, pt) match {
@@ -2228,7 +2228,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val pat1 = typedPattern(tree.pat, wideSelType)(using gadtCtx)
     caseRest(pat1)(
       using Nullables.caseContext(sel, pat1)(
-        using gadtCtx))
+        using gadtCtx.fresh.setNewScope))
   }
 
   def typedLabeled(tree: untpd.Labeled)(using Context): Labeled = {
diff --git a/tests/pos/i21742.1.scala b/tests/pos/i21742.1.scala
new file mode 100644
index 000000000000..c9c1a94b222c
--- /dev/null
+++ b/tests/pos/i21742.1.scala
@@ -0,0 +1,5 @@
+case class C(n: Int, ds: Double*)
+class Test:
+  def m(using n: Int): Int = n + 1
+  def t(): Unit =
+    C(1, 2, 3, 4) match { case C(given Int, ds*) => m }
diff --git a/tests/pos/i21742.2.scala b/tests/pos/i21742.2.scala
new file mode 100644
index 000000000000..83dc4b6ad46f
--- /dev/null
+++ b/tests/pos/i21742.2.scala
@@ -0,0 +1,5 @@
+case class C(n: Int, ds: Seq[Double])
+class Test:
+  def m(using n: Int): Int = n + 1
+  def t(): Unit =
+    C(1, Seq(2, 3, 4)) match { case C(given Int, ds) => m }

From e0428038159bff79774fd49c889f824f302dba9d Mon Sep 17 00:00:00 2001
From: Jamie Thompson <bishbashboshjt@gmail.com>
Date: Fri, 11 Oct 2024 01:00:36 +0200
Subject: [PATCH 019/306] fix code rendering error in givens.md

an extra code fence was added, so the bottom of the page is incorrectly rendered
---
 docs/_docs/reference/contextual/givens.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/docs/_docs/reference/contextual/givens.md b/docs/_docs/reference/contextual/givens.md
index 088ded2e8db4..9c074da0da6e 100644
--- a/docs/_docs/reference/contextual/givens.md
+++ b/docs/_docs/reference/contextual/givens.md
@@ -90,8 +90,6 @@ time it is accessed. If the given is a mere alias to some immutable value, the g
 Here is the full syntax for given instances. Some of these forms of givens are explained in a separate page: [Other Forms of Givens](../more-givens.md).
 
 ```ebnf
-Here is the complete context-free syntax for all proposed features.
-```
 TmplDef           ::=  ... | 'given' GivenDef
 GivenDef          ::=  [id ':'] GivenSig
 GivenSig          ::=  GivenImpl

From 9de4b7c3b7a0d35f75a5dd050e2eca58b9fd5152 Mon Sep 17 00:00:00 2001
From: Seth Tisue <seth@tisue.net>
Date: Thu, 10 Oct 2024 18:24:04 -0700
Subject: [PATCH 020/306] REPL: JLine 3.27.0 (was 3.25.1)

---
 project/Build.scala | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/project/Build.scala b/project/Build.scala
index 84ce00d11577..60511f648b57 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -694,9 +694,9 @@ object Build {
       libraryDependencies ++= Seq(
         "org.scala-lang.modules" % "scala-asm" % "9.7.0-scala-2", // used by the backend
         Dependencies.compilerInterface,
-        "org.jline" % "jline-reader" % "3.25.1",   // used by the REPL
-        "org.jline" % "jline-terminal" % "3.25.1",
-        "org.jline" % "jline-terminal-jna" % "3.25.1", // needed for Windows
+        "org.jline" % "jline-reader" % "3.27.0",   // used by the REPL
+        "org.jline" % "jline-terminal" % "3.27.0",
+        "org.jline" % "jline-terminal-jna" % "3.27.0", // needed for Windows
         ("io.get-coursier" %% "coursier" % "2.0.16" % Test).cross(CrossVersion.for3Use2_13),
       ),
 

From aee3230df033af599847d460ecd16064af9c702c Mon Sep 17 00:00:00 2001
From: Tomasz Godzik <tgodzik@virtuslab.com>
Date: Fri, 11 Oct 2024 18:43:25 +0200
Subject: [PATCH 021/306] backport: include inline when printing param names

---
 .../tools/pc/printer/ShortenedTypePrinter.scala      |  3 ++-
 .../pc/tests/completion/CompletionArgSuite.scala     | 12 ++++++------
 .../pc/tests/completion/CompletionCancelSuite.scala  |  4 ++--
 3 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/presentation-compiler/src/main/dotty/tools/pc/printer/ShortenedTypePrinter.scala b/presentation-compiler/src/main/dotty/tools/pc/printer/ShortenedTypePrinter.scala
index a738440c585d..d9c11a5ada8c 100644
--- a/presentation-compiler/src/main/dotty/tools/pc/printer/ShortenedTypePrinter.scala
+++ b/presentation-compiler/src/main/dotty/tools/pc/printer/ShortenedTypePrinter.scala
@@ -527,7 +527,8 @@ class ShortenedTypePrinter(
         else if includeDefaultParam == ShortenedTypePrinter.IncludeDefaultParam.ResolveLater && isDefaultParam
         then " = ..."
         else "" // includeDefaultParam == Never or !isDefaultParam
-      s"$keywordName: ${paramTypeString}$default"
+      val inline = if(param.is(Flags.Inline)) "inline " else ""
+      s"$inline$keywordName: ${paramTypeString}$default"
     end if
   end paramLabel
 
diff --git a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionArgSuite.scala b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionArgSuite.scala
index 17f21b16d6e8..dc81d2596c6f 100644
--- a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionArgSuite.scala
+++ b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionArgSuite.scala
@@ -796,7 +796,7 @@ class CompletionArgSuite extends BaseCompletionSuite:
          |  def k: Int = m(1, a@@)
          |""".stripMargin,
       """|aaa = : Int
-         |assert(assertion: Boolean): Unit
+         |assert(inline assertion: Boolean): Unit
          |""".stripMargin,
       topLines = Some(2),
     )
@@ -810,7 +810,7 @@ class CompletionArgSuite extends BaseCompletionSuite:
          |  def k: Int = m(inn = 1, a@@)
          |""".stripMargin,
       """|aaa = : Int
-         |assert(assertion: Boolean): Unit
+         |assert(inline assertion: Boolean): Unit
          |""".stripMargin,
       topLines = Some(2),
     )
@@ -912,7 +912,7 @@ class CompletionArgSuite extends BaseCompletionSuite:
          |""".stripMargin,
       """|aaa = : Int
          |abb = : Option[Int]
-         |assert(assertion: Boolean): Unit
+         |assert(inline assertion: Boolean): Unit
          |""".stripMargin,
       topLines = Some(3),
     )
@@ -927,7 +927,7 @@ class CompletionArgSuite extends BaseCompletionSuite:
          |""".stripMargin,
       """|aaa = : Int
          |abb = : Option[Int]
-         |assert(assertion: Boolean): Unit
+         |assert(inline assertion: Boolean): Unit
          |""".stripMargin,
       topLines = Some(3),
     )
@@ -945,7 +945,7 @@ class CompletionArgSuite extends BaseCompletionSuite:
          |""".stripMargin,
       """|aaa = : Int
          |abb = : Option[Int]
-         |assert(assertion: Boolean): Unit
+         |assert(inline assertion: Boolean): Unit
          |""".stripMargin,
       topLines = Some(3),
     )
@@ -963,7 +963,7 @@ class CompletionArgSuite extends BaseCompletionSuite:
          |""".stripMargin,
       """|abb = : Option[Int]
          |acc = : List[Int]
-         |assert(assertion: Boolean): Unit
+         |assert(inline assertion: Boolean): Unit
          |""".stripMargin,
       topLines = Some(3),
     )
diff --git a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionCancelSuite.scala b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionCancelSuite.scala
index 4746eb93f25d..c1d0e017def7 100644
--- a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionCancelSuite.scala
+++ b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionCancelSuite.scala
@@ -90,8 +90,8 @@ class CompletionCancelSuite extends BaseCompletionSuite:
         |  val x = asser@@
         |}
       """.stripMargin,
-      """|assert(assertion: Boolean): Unit
-         |assert(assertion: Boolean, message: => Any): Unit
+      """|assert(inline assertion: Boolean): Unit
+         |assert(inline assertion: Boolean, inline message: => Any): Unit
          |""".stripMargin
     )
 

From 6429b4b05bfc6904ef1fe76589a3bfe833383ef9 Mon Sep 17 00:00:00 2001
From: Tomasz Godzik <tgodzik@virtuslab.com>
Date: Fri, 11 Oct 2024 18:45:20 +0200
Subject: [PATCH 022/306] backport: use uri from params in pc for location

---
 .../src/main/dotty/tools/pc/PcDefinitionProvider.scala    | 8 ++++----
 .../dotty/tools/pc/utils/InteractiveEnrichments.scala     | 6 ------
 2 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/presentation-compiler/src/main/dotty/tools/pc/PcDefinitionProvider.scala b/presentation-compiler/src/main/dotty/tools/pc/PcDefinitionProvider.scala
index fc97dd1f1176..6f2f4cd5f34e 100644
--- a/presentation-compiler/src/main/dotty/tools/pc/PcDefinitionProvider.scala
+++ b/presentation-compiler/src/main/dotty/tools/pc/PcDefinitionProvider.scala
@@ -131,13 +131,13 @@ class PcDefinitionProvider(
           otherDefs.headOption.orElse(exportedDefs.headOption)  match
             case Some(srcTree) =>
               val pos = srcTree.namePos
-              pos.toLocation match
-                case None => DefinitionResultImpl.empty
-                case Some(loc) =>
+              if pos.exists then
+                  val loc = new Location(params.uri().toString(), pos.toLsp)
                   DefinitionResultImpl(
                     SemanticdbSymbols.symbolName(sym),
-                    List(loc).asJava
+                    List(loc).asJava,
                   )
+                else DefinitionResultImpl.empty
             case None =>
               DefinitionResultImpl.empty
         else
diff --git a/presentation-compiler/src/main/dotty/tools/pc/utils/InteractiveEnrichments.scala b/presentation-compiler/src/main/dotty/tools/pc/utils/InteractiveEnrichments.scala
index 8ff11694ff1c..66080a363d51 100644
--- a/presentation-compiler/src/main/dotty/tools/pc/utils/InteractiveEnrichments.scala
+++ b/presentation-compiler/src/main/dotty/tools/pc/utils/InteractiveEnrichments.scala
@@ -99,12 +99,6 @@ object InteractiveEnrichments extends CommonMtagsEnrichments:
     def focusAt(point: Int): SourcePosition =
       pos.withSpan(pos.span.withPoint(point).focus)
 
-    def toLocation: Option[l.Location] =
-      for
-        uri <- InteractiveDriver.toUriOption(pos.source)
-        range <- if pos.exists then Some(pos.toLsp) else None
-      yield new l.Location(uri.toString(), range)
-
     def encloses(other: SourcePosition): Boolean =
       pos.start <= other.start && pos.end >= other.end
 

From 87db0da58d70ace996b65c179baa48929526ab22 Mon Sep 17 00:00:00 2001
From: Tomasz Godzik <tgodzik@virtuslab.com>
Date: Fri, 11 Oct 2024 19:02:02 +0200
Subject: [PATCH 023/306] backport: Finer grained accessibility check for
 auto-imports

---
 .../tools/pc/CompilerSearchVisitor.scala      |  2 +-
 .../dotty/tools/pc/PcDefinitionProvider.scala |  2 +-
 .../completion/CompletionSnippetSuite.scala   | 23 +++++++++++++++++++
 .../pc/tests/completion/CompletionSuite.scala | 13 +++++++++++
 4 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/presentation-compiler/src/main/dotty/tools/pc/CompilerSearchVisitor.scala b/presentation-compiler/src/main/dotty/tools/pc/CompilerSearchVisitor.scala
index 035c1062a3e3..9fb84ee1f513 100644
--- a/presentation-compiler/src/main/dotty/tools/pc/CompilerSearchVisitor.scala
+++ b/presentation-compiler/src/main/dotty/tools/pc/CompilerSearchVisitor.scala
@@ -28,7 +28,7 @@ class CompilerSearchVisitor(
     owner.isStatic && owner.isPublic
 
   private def isAccessible(sym: Symbol): Boolean = try
-    sym != NoSymbol && sym.isPublic && sym.isStatic || isAccessibleImplicitClass(sym)
+    (sym != NoSymbol && sym.isAccessibleFrom(ctx.owner.info) && sym.isStatic) || isAccessibleImplicitClass(sym)
   catch
     case err: AssertionError =>
       logger.log(Level.WARNING, err.getMessage())
diff --git a/presentation-compiler/src/main/dotty/tools/pc/PcDefinitionProvider.scala b/presentation-compiler/src/main/dotty/tools/pc/PcDefinitionProvider.scala
index 6f2f4cd5f34e..3b2284bef1d0 100644
--- a/presentation-compiler/src/main/dotty/tools/pc/PcDefinitionProvider.scala
+++ b/presentation-compiler/src/main/dotty/tools/pc/PcDefinitionProvider.scala
@@ -137,7 +137,7 @@ class PcDefinitionProvider(
                     SemanticdbSymbols.symbolName(sym),
                     List(loc).asJava,
                   )
-                else DefinitionResultImpl.empty
+              else DefinitionResultImpl.empty
             case None =>
               DefinitionResultImpl.empty
         else
diff --git a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSnippetSuite.scala b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSnippetSuite.scala
index 381375c65131..a002e722f1f0 100644
--- a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSnippetSuite.scala
+++ b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSnippetSuite.scala
@@ -385,6 +385,29 @@ class CompletionSnippetSuite extends BaseCompletionSuite:
     )
 
   @Test def `no-apply` =
+    checkSnippet(
+      s"""|package example
+          |
+          |object Widget{}
+          |object Main {
+          |  Wi@@
+          |}
+          |""".stripMargin,
+      """|Widget -  example
+         |Window -  java.awt
+         |WindowPeer -  java.awt.peer
+         |WithFilter - [A](p: A => Boolean, xs: Array[A]): WithFilter[A]
+         |WithFilter - [A, CC[_$$2]](self: IterableOps[A, CC, ?], p: A => Boolean): WithFilter[A, CC]
+         |WithFilter - [K, V, IterableCC[_$$3], CC[_$$4,_$$5] <: IterableOps[?, AnyConstr, ?]](self: MapOps[K, V, CC, ?] & IterableOps[(K, V), IterableCC, ?], p: ((K, V)) => Boolean): WithFilter[K, V, IterableCC, CC]
+         |WithFilter - [K, V, IterableCC[_$$1], MapCC[X,Y] <: scala.collection.Map[X, Y], CC[X,Y] <: scala.collection.Map[X, Y] & SortedMapOps[X, Y, CC, ?]](self: SortedMapOps[K, V, CC, ?] & MapOps[K, V, MapCC, ?] & IterableOps[(K, V), IterableCC, ?], p: ((K, V)) => Boolean): WithFilter[K, V, IterableCC, MapCC, CC]
+         |WithFilter - [A, IterableCC[_$$1], CC[X] <: SortedSet[X]](self: SortedSetOps[A, CC, ?] & IterableOps[A, IterableCC, ?], p: A => Boolean): WithFilter[A, IterableCC, CC]
+         |WithFilter - (p: Char => Boolean, s: String): WithFilter
+         |WithFilter - [A](l: Stream[A] @uncheckedVariance, p: A => Boolean): WithFilter[A]
+         |""".stripMargin,
+      includeDetail = true,
+    )
+
+  @Test def `no-apply2` =
     checkSnippet(
       s"""|package example
           |
diff --git a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala
index 57975d2c8e98..1d525c17bdf1 100644
--- a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala
+++ b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala
@@ -2107,6 +2107,19 @@ class CompletionSuite extends BaseCompletionSuite:
         |""".stripMargin
    )
 
+  @Test def `shadowing` =
+   check(
+     """|package pkg
+        |object Main {
+        |  val x = ListBuff@@
+        |}
+        |""".stripMargin,
+     """|ListBuffer[A](elems: A*): ListBuffer[A] - scala.collection.mutable
+        |new ListBuffer[A]: ListBuffer[A] - scala.collection.mutable
+        |ListBuffer - scala.collection.mutable
+        |""".stripMargin
+   )
+
   @Test def `conflict-edit-2` =
     checkEdit(
       """|package a

From d459140ef14fe66644f90b9cc3b359e3cb3741ce Mon Sep 17 00:00:00 2001
From: Alexander <azazf93@gmail.com>
Date: Thu, 10 Oct 2024 22:18:26 +0300
Subject: [PATCH 024/306] Do not consider uninhabited constructors when
 performing exhaustive match checking

---
 .../tools/dotc/transform/patmat/Space.scala   | 35 ++++++++++++++-----
 tests/init-global/pos/i18629.scala            |  2 +-
 tests/patmat/i13931.scala                     |  2 +-
 tests/warn/patmat-nothing-exhaustive.scala    | 10 ++++++
 4 files changed, 38 insertions(+), 11 deletions(-)
 create mode 100644 tests/warn/patmat-nothing-exhaustive.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 20b0099d82e2..9fb3c00c67c4 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -648,21 +648,38 @@ object SpaceEngine {
         // we get
         //    <== refineUsingParent(NatT, class Succ, []) = Succ[NatT]
         //    <== isSub(Succ[NatT] <:< Succ[Succ[<?>]]) = false
-        def getAppliedClass(tp: Type): Type = tp match
-          case tp @ AppliedType(_: HKTypeLambda, _)                        => tp
-          case tp @ AppliedType(tycon: TypeRef, _) if tycon.symbol.isClass => tp
+        def getAppliedClass(tp: Type): (Type, List[Type]) = tp match
+          case tp @ AppliedType(_: HKTypeLambda, _)                        => (tp, Nil)
+          case tp @ AppliedType(tycon: TypeRef, _) if tycon.symbol.isClass => (tp, tp.args)
           case tp @ AppliedType(tycon: TypeProxy, _)                       => getAppliedClass(tycon.superType.applyIfParameterized(tp.args))
-          case tp                                                          => tp
-        val tp = getAppliedClass(tpOriginal)
-        def getChildren(sym: Symbol): List[Symbol] =
+          case tp                                                          => (tp, Nil)
+        val (tp, typeArgs) = getAppliedClass(tpOriginal)
+        // This function is needed to get the arguments of the types that will be applied to the class.
+        // This is necessary because if the arguments of the types contain Nothing, 
+        // then this can affect whether the class will be taken into account during the exhaustiveness check
+        def getTypeArgs(parent: Symbol, child: Symbol, typeArgs: List[Type]): List[Type] =
+          val superType = child.typeRef.superType
+          if typeArgs.exists(_.isBottomType) && superType.isInstanceOf[ClassInfo] then
+            val parentClass = superType.asInstanceOf[ClassInfo].declaredParents.find(_.classSymbol == parent).get
+            val paramTypeMap = Map.from(parentClass.argTypes.map(_.typeSymbol).zip(typeArgs))
+            val substArgs = child.typeRef.typeParamSymbols.map(param => paramTypeMap.getOrElse(param, WildcardType))
+            substArgs
+          else Nil
+        def getChildren(sym: Symbol, typeArgs: List[Type]): 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)
+            else if (child.is(Private) || child.is(Sealed)) && child.isOneOf(AbstractOrTrait) then
+              getChildren(child, getTypeArgs(sym, child, typeArgs))
+            else
+              val childSubstTypes = child.typeRef.applyIfParameterized(getTypeArgs(sym, child, typeArgs))
+              // if a class contains a field of type Nothing,
+              // then it can be ignored in pattern matching, because it is impossible to obtain an instance of it
+              val existFieldWithBottomType = childSubstTypes.fields.exists(_.info.isBottomType)
+              if existFieldWithBottomType then Nil else List(child)
           }
-        val children = trace(i"getChildren($tp)")(getChildren(tp.classSymbol))
+        val children = trace(i"getChildren($tp)")(getChildren(tp.classSymbol, typeArgs))
 
         val parts = children.map { sym =>
           val sym1 = if (sym.is(ModuleClass)) sym.sourceModule else sym
diff --git a/tests/init-global/pos/i18629.scala b/tests/init-global/pos/i18629.scala
index f97c21ee918d..03f1f5d5cda4 100644
--- a/tests/init-global/pos/i18629.scala
+++ b/tests/init-global/pos/i18629.scala
@@ -1,6 +1,6 @@
 object Foo {
   val bar = List() match {
     case List() => ???
-    case _ => ???
+    case null => ???
   }
 }
diff --git a/tests/patmat/i13931.scala b/tests/patmat/i13931.scala
index 0d8d9eb9dcd3..562f059771c1 100644
--- a/tests/patmat/i13931.scala
+++ b/tests/patmat/i13931.scala
@@ -3,5 +3,5 @@ class Test:
     case Seq() => println("empty")
     case _ => println("non-empty")
 
-  def test2 = IndexedSeq() match { case IndexedSeq() => case _ => }
+  def test2 = IndexedSeq() match { case IndexedSeq() => case null => }
   def test3 = IndexedSeq() match { case IndexedSeq(1) => case _ => }
diff --git a/tests/warn/patmat-nothing-exhaustive.scala b/tests/warn/patmat-nothing-exhaustive.scala
new file mode 100644
index 000000000000..4e9181256fda
--- /dev/null
+++ b/tests/warn/patmat-nothing-exhaustive.scala
@@ -0,0 +1,10 @@
+enum TestAdt:
+  case Inhabited
+  case Uninhabited(no: Nothing)
+
+def test1(t: TestAdt): Int = t match
+  case TestAdt.Inhabited => 1
+
+def test2(o: Option[Option[Nothing]]): Int = o match
+  case Some(None) => 1
+  case None => 2

From c6b23cc2944c183a36bc607e1eed9361cc9e3b83 Mon Sep 17 00:00:00 2001
From: Jamie Thompson <bishbashboshjt@gmail.com>
Date: Mon, 14 Oct 2024 15:20:12 +0200
Subject: [PATCH 025/306] backend computes line number from source of position

---
 .../src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala    | 8 +++++++-
 compiler/src/dotty/tools/dotc/util/SourceFile.scala       | 3 ++-
 compiler/src/dotty/tools/dotc/util/SourcePosition.scala   | 4 ++++
 3 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala b/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
index 394700c2898e..38e5617fc3d7 100644
--- a/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
+++ b/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
@@ -623,7 +623,13 @@ trait BCodeSkelBuilder extends BCodeHelpers {
       }
 
       if (emitLines && tree.span.exists && !tree.hasAttachment(SyntheticUnit)) {
-        val nr = ctx.source.offsetToLine(tree.span.point) + 1
+        val nr =
+          val sourcePos = tree.sourcePos
+          (
+            if sourcePos.exists then sourcePos.finalPosition.line
+            else ctx.source.offsetToLine(tree.span.point) // fallback
+          ) + 1
+
         if (nr != lastEmittedLineNr) {
           lastEmittedLineNr = nr
           getNonLabelNode(lastInsn) match {
diff --git a/compiler/src/dotty/tools/dotc/util/SourceFile.scala b/compiler/src/dotty/tools/dotc/util/SourceFile.scala
index 9da4f58f2deb..3ea43d16a7c8 100644
--- a/compiler/src/dotty/tools/dotc/util/SourceFile.scala
+++ b/compiler/src/dotty/tools/dotc/util/SourceFile.scala
@@ -119,7 +119,8 @@ class SourceFile(val file: AbstractFile, computeContent: => Array[Char]) extends
    *  For regular source files, simply return the argument.
    */
   def positionInUltimateSource(position: SourcePosition): SourcePosition =
-    SourcePosition(underlying, position.span shift start)
+    if isSelfContained then position // return the argument
+    else SourcePosition(underlying, position.span shift start)
 
   private def calculateLineIndicesFromContents() = {
     val cs = content()
diff --git a/compiler/src/dotty/tools/dotc/util/SourcePosition.scala b/compiler/src/dotty/tools/dotc/util/SourcePosition.scala
index 904704b2349c..384d2f1fb2f3 100644
--- a/compiler/src/dotty/tools/dotc/util/SourcePosition.scala
+++ b/compiler/src/dotty/tools/dotc/util/SourcePosition.scala
@@ -79,6 +79,10 @@ extends SrcPos, interfaces.SourcePosition, Showable {
     rec(this)
   }
 
+  def finalPosition: SourcePosition = {
+    source.positionInUltimateSource(this)
+  }
+
 
   override def toString: String =
     s"${if (source.exists) source.file.toString else "(no source)"}:$span"

From 731f61e567fde22cf463bc544b6aea1e8b159910 Mon Sep 17 00:00:00 2001
From: Adrien Piquerez <adrien.piquerez@gmail.com>
Date: Mon, 14 Oct 2024 16:47:53 +0200
Subject: [PATCH 026/306] Shade scalajs.ir under dotty.tools

---
 .../dotty/tools/backend/sjs/JSCodeGen.scala   | 14 ++++----
 .../dotty/tools/backend/sjs/JSEncoding.scala  | 12 +++----
 .../tools/backend/sjs/JSExportsGen.scala      | 14 ++++----
 .../dotty/tools/backend/sjs/JSPositions.scala |  2 +-
 .../tools/dotc/transform/CheckReentrant.scala |  2 +-
 .../tools/dotc/transform/sjs/JSSymUtils.scala |  2 +-
 .../dotc/transform/sjs/PrepJSExports.scala    |  4 +--
 .../dotc/transform/sjs/PrepJSInterop.scala    |  2 +-
 project/Build.scala                           | 35 +++++++++++++++----
 .../backend/sjs/JSCodeGen.scala               | 12 +++----
 .../backend/sjs/JSEncoding.scala              | 12 +++----
 .../backend/sjs/JSExportsGen.scala            | 12 +++----
 .../backend/sjs/JSPositions.scala             |  2 +-
 13 files changed, 73 insertions(+), 52 deletions(-)

diff --git a/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala b/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala
index 6e2449b5c299..7ba39768871b 100644
--- a/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala
+++ b/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala
@@ -25,13 +25,13 @@ import dotty.tools.dotc.transform.{Erasure, ValueClasses}
 import dotty.tools.dotc.util.SourcePosition
 import dotty.tools.dotc.report
 
-import org.scalajs.ir
-import org.scalajs.ir.{ClassKind, Position, Names => jsNames, Trees => js, Types => jstpe}
-import org.scalajs.ir.Names.{ClassName, MethodName, SimpleMethodName}
-import org.scalajs.ir.OriginalName
-import org.scalajs.ir.OriginalName.NoOriginalName
-import org.scalajs.ir.Trees.OptimizerHints
-import org.scalajs.ir.Version.Unversioned
+import dotty.tools.sjs.ir
+import dotty.tools.sjs.ir.{ClassKind, Position, Names => jsNames, Trees => js, Types => jstpe}
+import dotty.tools.sjs.ir.Names.{ClassName, MethodName, SimpleMethodName}
+import dotty.tools.sjs.ir.OriginalName
+import dotty.tools.sjs.ir.OriginalName.NoOriginalName
+import dotty.tools.sjs.ir.Trees.OptimizerHints
+import dotty.tools.sjs.ir.Version.Unversioned
 
 import dotty.tools.dotc.transform.sjs.JSSymUtils.*
 
diff --git a/compiler/src/dotty/tools/backend/sjs/JSEncoding.scala b/compiler/src/dotty/tools/backend/sjs/JSEncoding.scala
index 098f592daa30..9a7753680bc3 100644
--- a/compiler/src/dotty/tools/backend/sjs/JSEncoding.scala
+++ b/compiler/src/dotty/tools/backend/sjs/JSEncoding.scala
@@ -15,12 +15,12 @@ import StdNames.*
 
 import dotty.tools.dotc.transform.sjs.JSSymUtils.*
 
-import org.scalajs.ir
-import org.scalajs.ir.{Trees => js, Types => jstpe}
-import org.scalajs.ir.Names.{LocalName, LabelName, SimpleFieldName, FieldName, SimpleMethodName, MethodName, ClassName}
-import org.scalajs.ir.OriginalName
-import org.scalajs.ir.OriginalName.NoOriginalName
-import org.scalajs.ir.UTF8String
+import dotty.tools.sjs.ir
+import dotty.tools.sjs.ir.{Trees => js, Types => jstpe}
+import dotty.tools.sjs.ir.Names.{LocalName, LabelName, SimpleFieldName, FieldName, SimpleMethodName, MethodName, ClassName}
+import dotty.tools.sjs.ir.OriginalName
+import dotty.tools.sjs.ir.OriginalName.NoOriginalName
+import dotty.tools.sjs.ir.UTF8String
 
 import dotty.tools.backend.jvm.DottyBackendInterface.symExtensions
 
diff --git a/compiler/src/dotty/tools/backend/sjs/JSExportsGen.scala b/compiler/src/dotty/tools/backend/sjs/JSExportsGen.scala
index b5f9446758a9..e6c73357aa4c 100644
--- a/compiler/src/dotty/tools/backend/sjs/JSExportsGen.scala
+++ b/compiler/src/dotty/tools/backend/sjs/JSExportsGen.scala
@@ -22,12 +22,12 @@ import TypeErasure.ErasedValueType
 import dotty.tools.dotc.util.{SourcePosition, SrcPos}
 import dotty.tools.dotc.report
 
-import org.scalajs.ir.{Position, Names => jsNames, Trees => js, Types => jstpe}
-import org.scalajs.ir.Names.DefaultModuleID
-import org.scalajs.ir.OriginalName.NoOriginalName
-import org.scalajs.ir.Position.NoPosition
-import org.scalajs.ir.Trees.OptimizerHints
-import org.scalajs.ir.Version.Unversioned
+import dotty.tools.sjs.ir.{Position, Names => jsNames, Trees => js, Types => jstpe}
+import dotty.tools.sjs.ir.Names.DefaultModuleID
+import dotty.tools.sjs.ir.OriginalName.NoOriginalName
+import dotty.tools.sjs.ir.Position.NoPosition
+import dotty.tools.sjs.ir.Trees.OptimizerHints
+import dotty.tools.sjs.ir.Version.Unversioned
 
 import dotty.tools.dotc.transform.sjs.JSExportUtils.*
 import dotty.tools.dotc.transform.sjs.JSSymUtils.*
@@ -932,7 +932,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
         InstanceOfTypeTest(tpe.tycon.typeSymbol.typeRef)
 
       case _ =>
-        import org.scalajs.ir.Names
+        import dotty.tools.sjs.ir.Names
 
         (toIRType(tpe): @unchecked) match {
           case jstpe.AnyType => NoTypeTest
diff --git a/compiler/src/dotty/tools/backend/sjs/JSPositions.scala b/compiler/src/dotty/tools/backend/sjs/JSPositions.scala
index 3b25187b0acd..a229c9ea0e58 100644
--- a/compiler/src/dotty/tools/backend/sjs/JSPositions.scala
+++ b/compiler/src/dotty/tools/backend/sjs/JSPositions.scala
@@ -13,7 +13,7 @@ import dotty.tools.dotc.report
 import dotty.tools.dotc.util.{SourceFile, SourcePosition}
 import dotty.tools.dotc.util.Spans.Span
 
-import org.scalajs.ir
+import dotty.tools.sjs.ir
 
 /** Conversion utilities from dotty Positions to IR Positions. */
 class JSPositions()(using Context) {
diff --git a/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala b/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala
index 073086ac5e2c..e8a402068bfc 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala
@@ -43,7 +43,7 @@ class CheckReentrant extends MiniPhase {
     requiredClass("scala.annotation.internal.unshared"))
 
   private val scalaJSIRPackageClass = new CtxLazy(
-    getPackageClassIfDefined("org.scalajs.ir"))
+    getPackageClassIfDefined("dotty.tools.sjs.ir"))
 
   def isIgnored(sym: Symbol)(using Context): Boolean =
     sym.hasAnnotation(sharableAnnot()) ||
diff --git a/compiler/src/dotty/tools/dotc/transform/sjs/JSSymUtils.scala b/compiler/src/dotty/tools/dotc/transform/sjs/JSSymUtils.scala
index 936b6958fb33..87ee2be91465 100644
--- a/compiler/src/dotty/tools/dotc/transform/sjs/JSSymUtils.scala
+++ b/compiler/src/dotty/tools/dotc/transform/sjs/JSSymUtils.scala
@@ -17,7 +17,7 @@ import Types.*
 
 import dotty.tools.backend.sjs.JSDefinitions.jsdefn
 
-import org.scalajs.ir.{Trees => js}
+import dotty.tools.sjs.ir.{Trees => js}
 
 /** Additional extensions for `Symbol`s that are only relevant for Scala.js. */
 object JSSymUtils {
diff --git a/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSExports.scala b/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSExports.scala
index f66141bff8ad..5aa35a277cb5 100644
--- a/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSExports.scala
+++ b/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSExports.scala
@@ -21,8 +21,8 @@ import dotty.tools.backend.sjs.JSDefinitions.jsdefn
 import JSExportUtils.*
 import JSSymUtils.*
 
-import org.scalajs.ir.Names.DefaultModuleID
-import org.scalajs.ir.Trees.TopLevelExportDef.isValidTopLevelExportName
+import dotty.tools.sjs.ir.Names.DefaultModuleID
+import dotty.tools.sjs.ir.Trees.TopLevelExportDef.isValidTopLevelExportName
 
 object PrepJSExports {
   import tpd.*
diff --git a/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala b/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala
index 1b8fdd268ece..c7316482c193 100644
--- a/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala
+++ b/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala
@@ -23,7 +23,7 @@ import Types.*
 
 import JSSymUtils.*
 
-import org.scalajs.ir.Trees.JSGlobalRef
+import dotty.tools.sjs.ir.Trees.JSGlobalRef
 
 import dotty.tools.backend.sjs.JSDefinitions.jsdefn
 
diff --git a/project/Build.scala b/project/Build.scala
index 84ce00d11577..0cf4e3abcaaf 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -616,18 +616,36 @@ object Build {
   def findArtifactPath(classpath: Def.Classpath, name: String): String =
     findArtifact(classpath, name).getAbsolutePath
 
+  /** Replace package names in package definitions, for shading.
+   * It assumes the full package def is written on a single line.
+   * It does not adapt the imports accordingly.
+   */
+  def replacePackage(lines: List[String])(replace: PartialFunction[String, String]): List[String] = {
+    def recur(lines: List[String]): List[String] =
+      lines match {
+        case head :: tail =>
+          if (head.startsWith("package ")) {
+            val packageName = head.stripPrefix("package ").trim
+            val newPackageName = replace.applyOrElse(packageName, (_: String) => packageName)
+            s"package $newPackageName" :: tail
+          } else head :: recur(tail)
+        case _ => lines
+      }
+    recur(lines)
+  }
+
   /** Insert UnsafeNulls Import after package */
-  def insertUnsafeNullsImport(lines: Seq[String]): Seq[String] = {
-    def recur(ls: Seq[String], foundPackage: Boolean): Seq[String] = ls match {
-      case Seq(l, rest @ _*) =>
+  def insertUnsafeNullsImport(lines: List[String]): List[String] = {
+    def recur(ls: List[String], foundPackage: Boolean): List[String] = ls match {
+      case l :: rest =>
         val lt = l.trim()
         if (foundPackage) {
           if (!(lt.isEmpty || lt.startsWith("package ")))
-            "import scala.language.unsafeNulls" +: ls
-          else l +: recur(rest, foundPackage)
+            "import scala.language.unsafeNulls" :: ls
+          else l :: recur(rest, foundPackage)
         } else {
           if (lt.startsWith("package ")) l +: recur(rest, true)
-          else l +: recur(rest, foundPackage)
+          else l :: recur(rest, foundPackage)
         }
       case _ => ls
     }
@@ -928,7 +946,10 @@ object Build {
           val sjsSources = (trgDir ** "*.scala").get.toSet
           sjsSources.foreach(f => {
             val lines = IO.readLines(f)
-            IO.writeLines(f, insertUnsafeNullsImport(lines))
+            val linesWithPackage = replacePackage(lines) {
+              case "org.scalajs.ir" => "dotty.tools.sjs.ir"
+            }
+            IO.writeLines(f, insertUnsafeNullsImport(linesWithPackage))
           })
           sjsSources
         } (Set(scalaJSIRSourcesJar)).toSeq
diff --git a/tests/pos-with-compiler-cc/backend/sjs/JSCodeGen.scala b/tests/pos-with-compiler-cc/backend/sjs/JSCodeGen.scala
index c670b2de97b1..81f09b082850 100644
--- a/tests/pos-with-compiler-cc/backend/sjs/JSCodeGen.scala
+++ b/tests/pos-with-compiler-cc/backend/sjs/JSCodeGen.scala
@@ -25,12 +25,12 @@ import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.util.SourcePosition
 import dotty.tools.dotc.report
 
-import org.scalajs.ir
-import org.scalajs.ir.{ClassKind, Position, Names => jsNames, Trees => js, Types => jstpe}
-import org.scalajs.ir.Names.{ClassName, MethodName, SimpleMethodName}
-import org.scalajs.ir.OriginalName
-import org.scalajs.ir.OriginalName.NoOriginalName
-import org.scalajs.ir.Trees.OptimizerHints
+import dotty.tools.sjs.ir
+import dotty.tools.sjs.ir.{ClassKind, Position, Names => jsNames, Trees => js, Types => jstpe}
+import dotty.tools.sjs.ir.Names.{ClassName, MethodName, SimpleMethodName}
+import dotty.tools.sjs.ir.OriginalName
+import dotty.tools.sjs.ir.OriginalName.NoOriginalName
+import dotty.tools.sjs.ir.Trees.OptimizerHints
 
 import dotty.tools.dotc.transform.sjs.JSSymUtils._
 
diff --git a/tests/pos-with-compiler-cc/backend/sjs/JSEncoding.scala b/tests/pos-with-compiler-cc/backend/sjs/JSEncoding.scala
index 73a150c60290..518295543610 100644
--- a/tests/pos-with-compiler-cc/backend/sjs/JSEncoding.scala
+++ b/tests/pos-with-compiler-cc/backend/sjs/JSEncoding.scala
@@ -15,12 +15,12 @@ import StdNames._
 
 import dotty.tools.dotc.transform.sjs.JSSymUtils._
 
-import org.scalajs.ir
-import org.scalajs.ir.{Trees => js, Types => jstpe}
-import org.scalajs.ir.Names.{LocalName, LabelName, FieldName, SimpleMethodName, MethodName, ClassName}
-import org.scalajs.ir.OriginalName
-import org.scalajs.ir.OriginalName.NoOriginalName
-import org.scalajs.ir.UTF8String
+import dotty.tools.sjs.ir
+import dotty.tools.sjs.ir.{Trees => js, Types => jstpe}
+import dotty.tools.sjs.ir.Names.{LocalName, LabelName, FieldName, SimpleMethodName, MethodName, ClassName}
+import dotty.tools.sjs.ir.OriginalName
+import dotty.tools.sjs.ir.OriginalName.NoOriginalName
+import dotty.tools.sjs.ir.UTF8String
 
 import dotty.tools.backend.jvm.DottyBackendInterface.symExtensions
 
diff --git a/tests/pos-with-compiler-cc/backend/sjs/JSExportsGen.scala b/tests/pos-with-compiler-cc/backend/sjs/JSExportsGen.scala
index 78412999bb34..82b69e6a16a7 100644
--- a/tests/pos-with-compiler-cc/backend/sjs/JSExportsGen.scala
+++ b/tests/pos-with-compiler-cc/backend/sjs/JSExportsGen.scala
@@ -22,11 +22,11 @@ import TypeErasure.ErasedValueType
 import dotty.tools.dotc.util.{SourcePosition, SrcPos}
 import dotty.tools.dotc.report
 
-import org.scalajs.ir.{Position, Names => jsNames, Trees => js, Types => jstpe}
-import org.scalajs.ir.Names.DefaultModuleID
-import org.scalajs.ir.OriginalName.NoOriginalName
-import org.scalajs.ir.Position.NoPosition
-import org.scalajs.ir.Trees.OptimizerHints
+import dotty.tools.sjs.ir.{Position, Names => jsNames, Trees => js, Types => jstpe}
+import dotty.tools.sjs.ir.Names.DefaultModuleID
+import dotty.tools.sjs.ir.OriginalName.NoOriginalName
+import dotty.tools.sjs.ir.Position.NoPosition
+import dotty.tools.sjs.ir.Trees.OptimizerHints
 
 import dotty.tools.dotc.transform.sjs.JSExportUtils._
 import dotty.tools.dotc.transform.sjs.JSSymUtils._
@@ -924,7 +924,7 @@ final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
         InstanceOfTypeTest(tpe.tycon.typeSymbol.typeRef)
 
       case _ =>
-        import org.scalajs.ir.Names
+        import dotty.tools.sjs.ir.Names
 
         (toIRType(tpe): @unchecked) match {
           case jstpe.AnyType => NoTypeTest
diff --git a/tests/pos-with-compiler-cc/backend/sjs/JSPositions.scala b/tests/pos-with-compiler-cc/backend/sjs/JSPositions.scala
index 2fd007165952..620e76ab4bab 100644
--- a/tests/pos-with-compiler-cc/backend/sjs/JSPositions.scala
+++ b/tests/pos-with-compiler-cc/backend/sjs/JSPositions.scala
@@ -13,7 +13,7 @@ import dotty.tools.dotc.report
 import dotty.tools.dotc.util.{SourceFile, SourcePosition}
 import dotty.tools.dotc.util.Spans.Span
 
-import org.scalajs.ir
+import dotty.tools.sjs.ir
 
 /** Conversion utilities from dotty Positions to IR Positions. */
 class JSPositions()(using Context) {

From 54ddb427898fa1a245a4bed320c113b518ca6081 Mon Sep 17 00:00:00 2001
From: Jamie Thompson <bishbashboshjt@gmail.com>
Date: Mon, 14 Oct 2024 17:43:32 +0200
Subject: [PATCH 027/306] add demonstration of plugin adjusting positions

---
 .../BootstrappedOnlyCompilationTests.scala    |  8 ++-
 .../run/scriptWrapper/Framework_1.scala       |  3 +
 .../scriptWrapper/LineNumberPlugin_1.scala    | 68 +++++++++++++++++++
 tests/plugins/run/scriptWrapper/Test_3.scala  | 25 +++++++
 tests/plugins/run/scriptWrapper/foo_2.scala   | 18 +++++
 .../run/scriptWrapper/foo_original_2.scala    |  8 +++
 .../run/scriptWrapper/plugin.properties       |  1 +
 7 files changed, 129 insertions(+), 2 deletions(-)
 create mode 100644 tests/plugins/run/scriptWrapper/Framework_1.scala
 create mode 100644 tests/plugins/run/scriptWrapper/LineNumberPlugin_1.scala
 create mode 100644 tests/plugins/run/scriptWrapper/Test_3.scala
 create mode 100644 tests/plugins/run/scriptWrapper/foo_2.scala
 create mode 100644 tests/plugins/run/scriptWrapper/foo_original_2.scala
 create mode 100644 tests/plugins/run/scriptWrapper/plugin.properties

diff --git a/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala b/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala
index a40c1ec1e5b2..5cd4f837b823 100644
--- a/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala
@@ -193,7 +193,7 @@ class BootstrappedOnlyCompilationTests {
 
     // 1. hack with absolute path for -Xplugin
     // 2. copy `pluginFile` to destination
-    def compileFilesInDir(dir: String): CompilationTest = {
+    def compileFilesInDir(dir: String, run: Boolean = false): CompilationTest = {
       val outDir = defaultOutputDir + "testPlugins/"
       val sourceDir = new java.io.File(dir)
 
@@ -201,7 +201,10 @@ class BootstrappedOnlyCompilationTests {
       val targets = dirs.map { dir =>
         val compileDir = createOutputDirsForDir(dir, sourceDir, outDir)
         Files.copy(dir.toPath.resolve(pluginFile), compileDir.toPath.resolve(pluginFile), StandardCopyOption.REPLACE_EXISTING)
-        val flags = TestFlags(withCompilerClasspath, noCheckOptions).and("-Xplugin:" + compileDir.getAbsolutePath)
+        val flags = {
+          val base = TestFlags(withCompilerClasspath, noCheckOptions).and("-Xplugin:" + compileDir.getAbsolutePath)
+          if run then base.withRunClasspath(withCompilerClasspath) else base
+        }
         SeparateCompilationSource("testPlugins", dir, flags, compileDir)
       }
 
@@ -210,6 +213,7 @@ class BootstrappedOnlyCompilationTests {
 
     compileFilesInDir("tests/plugins/neg").checkExpectedErrors()
     compileDir("tests/plugins/custom/analyzer", withCompilerOptions.and("-Yretain-trees")).checkCompile()
+    compileFilesInDir("tests/plugins/run", run = true).checkRuns()
   }
 }
 
diff --git a/tests/plugins/run/scriptWrapper/Framework_1.scala b/tests/plugins/run/scriptWrapper/Framework_1.scala
new file mode 100644
index 000000000000..c8a15de8342b
--- /dev/null
+++ b/tests/plugins/run/scriptWrapper/Framework_1.scala
@@ -0,0 +1,3 @@
+package framework
+
+class entrypoint extends scala.annotation.Annotation
diff --git a/tests/plugins/run/scriptWrapper/LineNumberPlugin_1.scala b/tests/plugins/run/scriptWrapper/LineNumberPlugin_1.scala
new file mode 100644
index 000000000000..888d5f95838d
--- /dev/null
+++ b/tests/plugins/run/scriptWrapper/LineNumberPlugin_1.scala
@@ -0,0 +1,68 @@
+package scriptWrapper
+
+import dotty.tools.dotc.*
+import core.*
+import Contexts.Context
+import Contexts.ctx
+import plugins.*
+import ast.tpd
+import util.SourceFile
+
+class LineNumberPlugin extends StandardPlugin {
+  val name: String = "linenumbers"
+  val description: String = "adjusts line numbers of script files"
+
+  override def initialize(options: List[String])(using Context): List[PluginPhase] = FixLineNumbers() :: Nil
+}
+
+// Loosely follows Mill linenumbers plugin (scan for marker with "original" source, adjust line numbers to match)
+class FixLineNumbers extends PluginPhase {
+
+  val codeMarker = "//USER_CODE_HERE"
+
+  def phaseName: String = "fixLineNumbers"
+  override def runsAfter: Set[String] = Set("posttyper")
+  override def runsBefore: Set[String] = Set("pickler")
+
+  override def transformUnit(tree: tpd.Tree)(using Context): tpd.Tree = {
+    val sourceContent = ctx.source.content()
+    val lines = new String(sourceContent).linesWithSeparators.toVector
+    val codeMarkerLine = lines.indexWhere(_.startsWith(codeMarker))
+
+    if codeMarkerLine < 0 then
+      tree
+    else
+      val adjustedFile = lines.collectFirst {
+        case s"//USER_SRC_FILE:./$file" => file.trim
+      }.getOrElse("<unknown>")
+
+      val adjustedSrc = ctx.source.file.container.lookupName(adjustedFile, directory = false) match
+        case null =>
+          report.error(s"could not find file $adjustedFile", tree.sourcePos)
+          return tree
+        case file =>
+          SourceFile(file, scala.io.Codec.UTF8)
+
+      val userCodeOffset = ctx.source.lineToOffset(codeMarkerLine + 1) // lines.take(codeMarkerLine).map(_.length).sum
+      val lineMapper = LineMapper(codeMarkerLine, userCodeOffset, adjustedSrc)
+      lineMapper.transform(tree)
+  }
+
+}
+
+class LineMapper(markerLine: Int, userCodeOffset: Int, adjustedSrc: SourceFile) extends tpd.TreeMapWithPreciseStatContexts() {
+
+  override def transform(tree: tpd.Tree)(using Context): tpd.Tree = {
+    val tree0 = super.transform(tree)
+    val pos = tree0.sourcePos
+    if pos.exists && pos.start >= userCodeOffset then
+      val tree1 = tree0.cloneIn(adjustedSrc).withSpan(pos.span.shift(-userCodeOffset))
+      // if tree1.show.toString == "???" then
+      //   val pos1 = tree1.sourcePos
+      //   sys.error(s"rewrote ??? at ${pos1.source}:${pos1.line + 1}:${pos1.column + 1} (sourced from ${markerLine + 2})")
+      tree1
+    else
+      tree0
+  }
+
+}
diff --git a/tests/plugins/run/scriptWrapper/Test_3.scala b/tests/plugins/run/scriptWrapper/Test_3.scala
new file mode 100644
index 000000000000..341af27ee433
--- /dev/null
+++ b/tests/plugins/run/scriptWrapper/Test_3.scala
@@ -0,0 +1,25 @@
+@main def Test: Unit = {
+  val mainCls = Class.forName("foo_sc")
+  val mainMethod = mainCls.getMethod("main", classOf[Array[String]])
+  val stackTrace: Array[String] = {
+    try
+      mainMethod.invoke(null, Array.empty[String])
+      sys.error("Expected an exception")
+    catch
+      case e: java.lang.reflect.InvocationTargetException =>
+        val cause = e.getCause
+        if cause != null then
+          cause.getStackTrace.map(_.toString)
+        else
+          throw e
+  }
+
+  val expected = Set(
+    "foo_sc$.getRandom(foo_2.scala:3)", // adjusted line number (11 -> 3)
+    "foo_sc$.brokenRandom(foo_2.scala:5)", // adjusted line number (13 -> 5)
+    "foo_sc$.run(foo_2.scala:8)", // adjusted line number (16 -> 8)
+  )
+
+  val missing = expected -- stackTrace
+  assert(missing.isEmpty, s"Missing: $missing")
+}
diff --git a/tests/plugins/run/scriptWrapper/foo_2.scala b/tests/plugins/run/scriptWrapper/foo_2.scala
new file mode 100644
index 000000000000..02e3f034e757
--- /dev/null
+++ b/tests/plugins/run/scriptWrapper/foo_2.scala
@@ -0,0 +1,18 @@
+// generated code
+// script: foo.sc
+object foo_sc {
+def main(args: Array[String]): Unit = {
+  run // assume some macro generates this by scanning for @entrypoint
+}
+//USER_SRC_FILE:./foo_original_2.scala
+//USER_CODE_HERE
+import framework.*
+
+def getRandom: Int = brokenRandom // LINE 3;
+
+def brokenRandom: Int = ??? // LINE 5;
+
+@entrypoint
+def run = println("Hello, here is a random number: " + getRandom) // LINE 8;
+//END_USER_CODE_HERE
+}
diff --git a/tests/plugins/run/scriptWrapper/foo_original_2.scala b/tests/plugins/run/scriptWrapper/foo_original_2.scala
new file mode 100644
index 000000000000..162ddd1724a1
--- /dev/null
+++ b/tests/plugins/run/scriptWrapper/foo_original_2.scala
@@ -0,0 +1,8 @@
+import framework.*
+
+def getRandom: Int = brokenRandom // LINE 3;
+
+def brokenRandom: Int = ??? // LINE 5;
+
+@entrypoint
+def run = println("Hello, here is a random number: " + getRandom) // LINE 8;
diff --git a/tests/plugins/run/scriptWrapper/plugin.properties b/tests/plugins/run/scriptWrapper/plugin.properties
new file mode 100644
index 000000000000..f1fc6067e611
--- /dev/null
+++ b/tests/plugins/run/scriptWrapper/plugin.properties
@@ -0,0 +1 @@
+pluginClass=scriptWrapper.LineNumberPlugin

From 44ecf4beb7b7b748ccf58d2bb3329ec87eb61d2b Mon Sep 17 00:00:00 2001
From: Jamie Thompson <bishbashboshjt@gmail.com>
Date: Mon, 14 Oct 2024 18:12:41 +0200
Subject: [PATCH 028/306] dont introduce new API

---
 compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala | 2 +-
 compiler/src/dotty/tools/dotc/util/SourcePosition.scala     | 5 -----
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala b/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
index 38e5617fc3d7..4f4caf36d92a 100644
--- a/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
+++ b/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
@@ -626,7 +626,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
         val nr =
           val sourcePos = tree.sourcePos
           (
-            if sourcePos.exists then sourcePos.finalPosition.line
+            if sourcePos.exists then sourcePos.source.positionInUltimateSource(sourcePos).line
             else ctx.source.offsetToLine(tree.span.point) // fallback
           ) + 1
 
diff --git a/compiler/src/dotty/tools/dotc/util/SourcePosition.scala b/compiler/src/dotty/tools/dotc/util/SourcePosition.scala
index 384d2f1fb2f3..a7358755043c 100644
--- a/compiler/src/dotty/tools/dotc/util/SourcePosition.scala
+++ b/compiler/src/dotty/tools/dotc/util/SourcePosition.scala
@@ -79,11 +79,6 @@ extends SrcPos, interfaces.SourcePosition, Showable {
     rec(this)
   }
 
-  def finalPosition: SourcePosition = {
-    source.positionInUltimateSource(this)
-  }
-
-
   override def toString: String =
     s"${if (source.exists) source.file.toString else "(no source)"}:$span"
 

From b94160bceeec20950875644f17593f169208e07e Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Tue, 15 Oct 2024 16:47:43 +0200
Subject: [PATCH 029/306] Fix relative docs in `givens.md` (#21774)

Previously were referring to non-exisitng file in the outer directory.

[skip ci]
---
 docs/_docs/reference/contextual/givens.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/_docs/reference/contextual/givens.md b/docs/_docs/reference/contextual/givens.md
index 9c074da0da6e..2b360dfc7af0 100644
--- a/docs/_docs/reference/contextual/givens.md
+++ b/docs/_docs/reference/contextual/givens.md
@@ -87,7 +87,7 @@ time it is accessed. If the given is a mere alias to some immutable value, the g
 
 ## Syntax
 
-Here is the full syntax for given instances. Some of these forms of givens are explained in a separate page: [Other Forms of Givens](../more-givens.md).
+Here is the full syntax for given instances. Some of these forms of givens are explained in a separate page: [Other Forms of Givens](./more-givens.md).
 
 ```ebnf
 TmplDef           ::=  ... | 'given' GivenDef
@@ -113,4 +113,4 @@ A given instance starts with the reserved keyword `given`, which is followed by
     - A _structural given_ implements one or more class constructors with a
       list of member definitions in a template body.
 
-**Note** Parts of the given syntax have changed in Scala 3.6. The original syntax from Scala 3.0 on is described in a separate page [Previous Given Syntax](../previous-givens.md). The original syntax is still supported for now but will be deprecated and phased out over time.
+**Note** Parts of the given syntax have changed in Scala 3.6. The original syntax from Scala 3.0 on is described in a separate page [Previous Given Syntax](./previous-givens.md). The original syntax is still supported for now but will be deprecated and phased out over time.

From e546f0779905e8a2ca8df68139b808ec89213008 Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Tue, 15 Oct 2024 16:58:30 +0200
Subject: [PATCH 030/306] Add so68877939.scala

---
 tests/pos/so68877939.scala | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 tests/pos/so68877939.scala

diff --git a/tests/pos/so68877939.scala b/tests/pos/so68877939.scala
new file mode 100644
index 000000000000..41c5ee8ac659
--- /dev/null
+++ b/tests/pos/so68877939.scala
@@ -0,0 +1,15 @@
+abstract class Quantity[A <: Quantity[A]]
+sealed trait UnitOfMeasure[A <: Quantity[A]]
+
+class Time extends Quantity[Time]
+object Minutes extends UnitOfMeasure[Time]
+
+class PowerRamp extends Quantity[PowerRamp]
+object KilowattsPerHour extends UnitOfMeasure[PowerRamp]
+
+type Test[X <: UnitOfMeasure[?]] = X match
+  case UnitOfMeasure[t] => t
+
+@main def main =
+  summon[Test[Minutes.type] =:= Time]
+  summon[Test[KilowattsPerHour.type] =:= PowerRamp]

From f6bfa0afddd35bc965e5930f1e050e293cf9dfe1 Mon Sep 17 00:00:00 2001
From: Seth Tisue <seth@tisue.net>
Date: Tue, 15 Oct 2024 11:09:50 -0700
Subject: [PATCH 031/306] Scala 2.13.15 (was .14) (#21648)

Co-authored-by: Wojciech Mazur <wmazur@virtuslab.com>
---
 .../community-projects/scala-collection-compat         |  2 +-
 community-build/community-projects/stdLib213           |  2 +-
 .../src/scala/dotty/communitybuild/projects.scala      |  4 ++--
 project/Build.scala                                    | 10 +++++-----
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/community-build/community-projects/scala-collection-compat b/community-build/community-projects/scala-collection-compat
index 2bf3fea914b2..c9d3a8b160a3 160000
--- a/community-build/community-projects/scala-collection-compat
+++ b/community-build/community-projects/scala-collection-compat
@@ -1 +1 @@
-Subproject commit 2bf3fea914b2f13e4805b3e7b519bdf0e595e4c9
+Subproject commit c9d3a8b160a35c9915816dd84a1063e18db4a84a
diff --git a/community-build/community-projects/stdLib213 b/community-build/community-projects/stdLib213
index fcc67cd56c67..b6f70d2347f2 160000
--- a/community-build/community-projects/stdLib213
+++ b/community-build/community-projects/stdLib213
@@ -1 +1 @@
-Subproject commit fcc67cd56c67851bf31019ec25ccb09d08b9561b
+Subproject commit b6f70d2347f2857695e5c0fe544b0f921544b02a
diff --git a/community-build/src/scala/dotty/communitybuild/projects.scala b/community-build/src/scala/dotty/communitybuild/projects.scala
index e8d6c3d2894d..31c1bb95743c 100644
--- a/community-build/src/scala/dotty/communitybuild/projects.scala
+++ b/community-build/src/scala/dotty/communitybuild/projects.scala
@@ -476,8 +476,8 @@ object projects:
 
   lazy val scalaCollectionCompat = SbtCommunityProject(
     project        = "scala-collection-compat",
-    sbtTestCommand = "compat30/test",
-    sbtPublishCommand = "compat30/publishLocal",
+    sbtTestCommand = "compat3/test",
+    sbtPublishCommand = "compat3/publishLocal",
   )
 
   lazy val scalaJava8Compat = SbtCommunityProject(
diff --git a/project/Build.scala b/project/Build.scala
index 9b4e24f37c75..5b04d623f122 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -149,8 +149,8 @@ object Build {
    *  scala-library.
    */
   def stdlibVersion(implicit mode: Mode): String = mode match {
-    case NonBootstrapped => "2.13.14"
-    case Bootstrapped => "2.13.14"
+    case NonBootstrapped => "2.13.15"
+    case Bootstrapped => "2.13.15"
   }
 
   /** Version of the scala-library for which we will generate TASTy.
@@ -160,7 +160,7 @@ object Build {
    *  We can use nightly versions to tests the future compatibility in development.
    *  Nightly versions: https://scala-ci.typesafe.com/ui/native/scala-integration/org/scala-lang
    */
-  val stdlibBootstrappedVersion = "2.13.14"
+  val stdlibBootstrappedVersion = "2.13.15"
 
   val dottyOrganization = "org.scala-lang"
   val dottyGithubUrl = "https://github.com/scala/scala3"
@@ -1426,7 +1426,7 @@ object Build {
       BuildInfoPlugin.buildInfoDefaultSettings
 
   lazy val presentationCompilerSettings = {
-    val mtagsVersion = "1.3.4"
+    val mtagsVersion = "1.3.5"
     Seq(
       libraryDependencies ++= Seq(
         "org.lz4" % "lz4-java" % "1.8.0",
@@ -1436,7 +1436,7 @@ object Build {
           .exclude("org.eclipse.lsp4j","org.eclipse.lsp4j.jsonrpc"),
         "org.eclipse.lsp4j" % "org.eclipse.lsp4j" % "0.20.1",
       ),
-      libraryDependencies += ("org.scalameta" % "mtags-shared_2.13.14" % mtagsVersion % SourceDeps),
+      libraryDependencies += ("org.scalameta" % "mtags-shared_2.13.15" % mtagsVersion % SourceDeps),
       ivyConfigurations += SourceDeps.hide,
       transitiveClassifiers := Seq("sources"),
       scalacOptions ++= Seq("-source", "3.3"), // To avoid fatal migration warnings

From af9ee8ea8f232e08d5248d088fae00949f608f36 Mon Sep 17 00:00:00 2001
From: Georgi Krastev <joro.kr.21@gmail.com>
Date: Wed, 16 Oct 2024 10:40:02 +0200
Subject: [PATCH 032/306] Fix tupleTypeFromSeq for XXL tuples

---
 library/src/scala/quoted/Expr.scala |  2 +-
 tests/pos/i21779/Macro_1.scala      | 36 +++++++++++++++++++++++++++++
 tests/pos/i21779/Test_2.scala       |  3 +++
 3 files changed, 40 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i21779/Macro_1.scala
 create mode 100644 tests/pos/i21779/Test_2.scala

diff --git a/library/src/scala/quoted/Expr.scala b/library/src/scala/quoted/Expr.scala
index f1045e5bdaca..d1385a0193d6 100644
--- a/library/src/scala/quoted/Expr.scala
+++ b/library/src/scala/quoted/Expr.scala
@@ -256,7 +256,7 @@ object Expr {
   private def tupleTypeFromSeq(seq: Seq[Expr[Any]])(using Quotes): quotes.reflect.TypeRepr =
     import quotes.reflect.*
     val consRef = Symbol.classSymbol("scala.*:").typeRef
-    seq.foldLeft(TypeRepr.of[EmptyTuple]) { (ts, expr) =>
+    seq.foldRight(TypeRepr.of[EmptyTuple]) { (expr, ts) =>
       AppliedType(consRef, expr.asTerm.tpe :: ts :: Nil)
     }
 
diff --git a/tests/pos/i21779/Macro_1.scala b/tests/pos/i21779/Macro_1.scala
new file mode 100644
index 000000000000..d40f5e28de5e
--- /dev/null
+++ b/tests/pos/i21779/Macro_1.scala
@@ -0,0 +1,36 @@
+import scala.quoted.*
+
+object Macro:
+  transparent inline def tupleXxl: Tuple =
+    ${tupleXxlExpr}
+
+  def tupleXxlExpr(using Quotes) =
+    import quotes.reflect.*
+    Expr.ofTupleFromSeq(
+      Seq(
+        Expr("a"),
+        Expr(2),
+        Expr(3),
+        Expr(4),
+        Expr(5),
+        Expr(6),
+        Expr(7),
+        Expr(8),
+        Expr(9),
+        Expr(10),
+        Expr(11),
+        Expr(12),
+        Expr(13),
+        Expr(14),
+        Expr(15),
+        Expr(16),
+        Expr(17),
+        Expr(18),
+        Expr(19),
+        Expr(20),
+        Expr(21),
+        Expr(22),
+        Expr(23),
+      )
+    )
+
diff --git a/tests/pos/i21779/Test_2.scala b/tests/pos/i21779/Test_2.scala
new file mode 100644
index 000000000000..e614e3ca564d
--- /dev/null
+++ b/tests/pos/i21779/Test_2.scala
@@ -0,0 +1,3 @@
+object Test:
+  val result: ("a", 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23) =
+    Macro.tupleXxl

From 5a68b16cc6632504ceed509772ef0e4aad8d5025 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Wed, 16 Oct 2024 14:20:13 +0200
Subject: [PATCH 033/306] Add a docs page for betterFors experimental feature

---
 .../reference/experimental/better-fors.md     | 79 +++++++++++++++++++
 1 file changed, 79 insertions(+)
 create mode 100644 docs/_docs/reference/experimental/better-fors.md

diff --git a/docs/_docs/reference/experimental/better-fors.md b/docs/_docs/reference/experimental/better-fors.md
new file mode 100644
index 000000000000..7add425caf51
--- /dev/null
+++ b/docs/_docs/reference/experimental/better-fors.md
@@ -0,0 +1,79 @@
+---
+layout: doc-page
+title: "Better fors"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/experimental/better-fors.html
+---
+
+The `betterFors` language extension improves the usability of `for`-comprehensions.
+
+The extension is enabled by the language import `import scala.language.experimental.betterFors` or by setting the command line option `-language:experimental.betterFors`.
+
+The biggest user facing change is the new ability to start `for`-comprehensions with with aliases. This means that the following previously invalid code is now valid:
+
+```scala
+for
+  as = List(1, 2, 3)
+  bs = List(4, 5, 6)
+  a <- as
+  b <- bs
+yield a + b
+```
+
+The desugaring of this code is the same as if the aliases were introduced with `val`:
+
+```scala
+val as = List(1, 2, 3)
+val bs = List(4, 5, 6)
+for
+  a <- as
+  b <- bs
+yield a + b
+```
+
+Additionally this extension changes the way `for`-comprehensions are desugared. The desugaring is now done in a more intuitive way and the desugared code can be more efficient, because it avoids some unnecessary method calls. There are two main changes in the desugaring:
+
+1. **Simpler Desugaring for Pure Aliases**:
+    When an alias is not followed by a guard, the desugaring is simplified. The last generator and the aliases don't have to be wrapped in a tuple, and instead the aliases are simply introduced as local variables in a block with the next generator.
+    **Current Desugaring**:
+      ```scala
+      for {
+        a <- doSth(arg)
+        b = a
+      } yield a + b
+      ```
+      Desugars to:
+      ```scala
+      doSth(arg).map { a =>
+        val b = a
+        (a, b)
+      }.map { case (a, b) =>
+        a + b
+      }
+      ```
+    **New Desugaring**:
+      ```scala
+      doSth(arg).map { a =>
+        val b = a
+        a + b
+      }
+      ```
+    This change makes the desugaring more intuitive and avoids unnecessary `map` calls, when an alias is not followed by a guard.
+
+2. **Avoiding Redundant `map` Calls**:
+    When the result of the `for`-comprehension is the same expression as the last generator pattern, the desugaring avoids an unnecessary `map` call. but th eequality of the last pattern and the result has to be able to be checked syntactically, so it is either a variable or a tuple of variables.
+    **Current Desugaring**:
+      ```scala
+      for {
+        a <- List(1, 2, 3)
+      } yield a
+      ```
+      Desugars to:
+      ```scala
+      List(1, 2, 3).map(a => a)
+      ```
+    **New Desugaring**:
+      ```scala
+      List(1, 2, 3)
+      ```
+
+For more details on the desugaring scheme see the comment in [`Desugar.scala#makeFor`](https://github.com/scala/scala3/blob/main/compiler/src/dotty/tools/dotc/ast/Desugar.scala#L1928).
\ No newline at end of file

From a4387dbc8383f76a7be66b03c4598fcc16741727 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Pa=C5=82ka?= <prolativus@gmail.com>
Date: Wed, 16 Oct 2024 15:55:59 +0200
Subject: [PATCH 034/306] Apply implicit conversion from derived Conversion
 instance defined as implicit rather than given

---
 .../dotty/tools/dotc/typer/Implicits.scala    |  2 +-
 tests/pos/i21757.scala                        | 33 +++++++++++++++++++
 2 files changed, 34 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i21757.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 3c2f025dc095..c42b196b8dfb 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -1176,7 +1176,7 @@ trait Implicits:
             case _ => info.derivesFrom(defn.ConversionClass)
           def tryConversion(using Context) = {
             val untpdConv =
-              if ref.symbol.is(Given) && producesConversion(ref.symbol.info) then
+              if ref.symbol.isOneOf(GivenOrImplicit) && producesConversion(ref.symbol.info) then
                 untpd.Select(
                   untpd.TypedSplice(
                     adapt(generated,
diff --git a/tests/pos/i21757.scala b/tests/pos/i21757.scala
new file mode 100644
index 000000000000..7595540c4b58
--- /dev/null
+++ b/tests/pos/i21757.scala
@@ -0,0 +1,33 @@
+object ConversionChain {
+
+  class X(val value: Int)
+
+  class Y(val x: X)
+
+  class Z(val y: Y)
+
+  trait Conv[A, B] extends Conversion[A, B]
+
+  given xy: Conv[X, Y] = { (x: X) => new Y(x) }
+
+  given yz: Conv[Y, Z] = { (y: Y) => new Z(y) }
+
+  object ConvUtils {
+    implicit def hypotheticalSyllogism[A, B, C]( // implicit def instead of given
+        using
+        ab: Conv[A, B],
+        bc: Conv[B, C]
+    ): Conv[A, C] = {
+
+      new Conv[A, C] {
+        def apply(a: A): C = bc(ab(a))
+      }
+    }
+  }
+  import ConvUtils.hypotheticalSyllogism
+
+  def test(): Unit = {
+    val x = new X(42)
+    val z: Z = x
+  }
+}

From 7f70ed3a3d100b697d18b541a0ec09ca788b826d Mon Sep 17 00:00:00 2001
From: Jan Chyb <jan.chyb.99@gmail.com>
Date: Wed, 16 Oct 2024 18:42:12 +0200
Subject: [PATCH 035/306] Add the macro type-print test to an
 run-macros-scala2-library-tasty.blacklist

---
 compiler/test/dotc/run-macros-scala2-library-tasty.blacklist | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/test/dotc/run-macros-scala2-library-tasty.blacklist b/compiler/test/dotc/run-macros-scala2-library-tasty.blacklist
index 63a6e2cee345..6fdfccf7646c 100644
--- a/compiler/test/dotc/run-macros-scala2-library-tasty.blacklist
+++ b/compiler/test/dotc/run-macros-scala2-library-tasty.blacklist
@@ -2,3 +2,4 @@
 tasty-extractors-1
 tasty-extractors-2
 tasty-extractors-types
+type-print

From 116f5fe7dab5e5088fd43ad64208e0f0b01c146b Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 16 Oct 2024 20:35:00 +0100
Subject: [PATCH 036/306] Add jzon repro

---
 tests/pos/jzon/SealedTrait.scala |  132 ++
 tests/pos/jzon/encoders.scala    | 2932 ++++++++++++++++++++++++++++++
 2 files changed, 3064 insertions(+)
 create mode 100644 tests/pos/jzon/SealedTrait.scala
 create mode 100644 tests/pos/jzon/encoders.scala

diff --git a/tests/pos/jzon/SealedTrait.scala b/tests/pos/jzon/SealedTrait.scala
new file mode 100644
index 000000000000..e83a68a331ef
--- /dev/null
+++ b/tests/pos/jzon/SealedTrait.scala
@@ -0,0 +1,132 @@
+trait Shape[T]
+sealed trait SealedTrait[T] extends Shape[T]:
+  def value: T
+sealed trait SealedTrait1[A, A1 <: A] extends SealedTrait[A]
+sealed trait SealedTrait2[A, A1 <: A, A2 <: A] extends SealedTrait[A]
+sealed trait SealedTrait3[A, A1 <: A, A2 <: A, A3 <: A] extends SealedTrait[A]
+sealed trait SealedTrait4[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A] extends SealedTrait[A]
+sealed trait SealedTrait5[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A] extends SealedTrait[A]
+sealed trait SealedTrait6[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A] extends SealedTrait[A]
+sealed trait SealedTrait7[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A] extends SealedTrait[A]
+sealed trait SealedTrait8[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A] extends SealedTrait[A]
+sealed trait SealedTrait9[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A] extends SealedTrait[A]
+sealed trait SealedTrait10[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A] extends SealedTrait[A]
+sealed trait SealedTrait11[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A] extends SealedTrait[A]
+sealed trait SealedTrait12[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A] extends SealedTrait[A]
+sealed trait SealedTrait13[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A] extends SealedTrait[A]
+sealed trait SealedTrait14[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A] extends SealedTrait[A]
+sealed trait SealedTrait15[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A] extends SealedTrait[A]
+sealed trait SealedTrait16[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A] extends SealedTrait[A]
+sealed trait SealedTrait17[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A] extends SealedTrait[A]
+sealed trait SealedTrait18[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A] extends SealedTrait[A]
+sealed trait SealedTrait19[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A] extends SealedTrait[A]
+sealed trait SealedTrait20[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A] extends SealedTrait[A]
+sealed trait SealedTrait21[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A] extends SealedTrait[A]
+sealed trait SealedTrait22[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A] extends SealedTrait[A]
+sealed trait SealedTrait23[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A] extends SealedTrait[A]
+sealed trait SealedTrait24[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A] extends SealedTrait[A]
+sealed trait SealedTrait25[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A] extends SealedTrait[A]
+sealed trait SealedTrait26[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A] extends SealedTrait[A]
+sealed trait SealedTrait27[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A] extends SealedTrait[A]
+sealed trait SealedTrait28[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A] extends SealedTrait[A]
+sealed trait SealedTrait29[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A] extends SealedTrait[A]
+sealed trait SealedTrait30[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A] extends SealedTrait[A]
+sealed trait SealedTrait31[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A] extends SealedTrait[A]
+sealed trait SealedTrait32[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A] extends SealedTrait[A]
+sealed trait SealedTrait33[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A] extends SealedTrait[A]
+sealed trait SealedTrait34[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A] extends SealedTrait[A]
+sealed trait SealedTrait35[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A] extends SealedTrait[A]
+sealed trait SealedTrait36[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A] extends SealedTrait[A]
+sealed trait SealedTrait37[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A] extends SealedTrait[A]
+sealed trait SealedTrait38[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A] extends SealedTrait[A]
+sealed trait SealedTrait39[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A] extends SealedTrait[A]
+sealed trait SealedTrait40[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A] extends SealedTrait[A]
+sealed trait SealedTrait41[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A] extends SealedTrait[A]
+sealed trait SealedTrait42[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A] extends SealedTrait[A]
+sealed trait SealedTrait43[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A] extends SealedTrait[A]
+sealed trait SealedTrait44[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A] extends SealedTrait[A]
+sealed trait SealedTrait45[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A] extends SealedTrait[A]
+sealed trait SealedTrait46[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A] extends SealedTrait[A]
+sealed trait SealedTrait47[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A] extends SealedTrait[A]
+sealed trait SealedTrait48[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A] extends SealedTrait[A]
+sealed trait SealedTrait49[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A] extends SealedTrait[A]
+sealed trait SealedTrait50[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A] extends SealedTrait[A]
+sealed trait SealedTrait51[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A] extends SealedTrait[A]
+sealed trait SealedTrait52[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A] extends SealedTrait[A]
+sealed trait SealedTrait53[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A] extends SealedTrait[A]
+sealed trait SealedTrait54[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A] extends SealedTrait[A]
+sealed trait SealedTrait55[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A] extends SealedTrait[A]
+sealed trait SealedTrait56[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A] extends SealedTrait[A]
+sealed trait SealedTrait57[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A] extends SealedTrait[A]
+sealed trait SealedTrait58[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A] extends SealedTrait[A]
+sealed trait SealedTrait59[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A] extends SealedTrait[A]
+sealed trait SealedTrait60[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A] extends SealedTrait[A]
+sealed trait SealedTrait61[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A] extends SealedTrait[A]
+sealed trait SealedTrait62[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A] extends SealedTrait[A]
+sealed trait SealedTrait63[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A] extends SealedTrait[A]
+sealed trait SealedTrait64[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A] extends SealedTrait[A]
+object SealedTrait:
+  final case class _1[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A1) extends SealedTrait1[A, A1], SealedTrait2[A, A1, A2], SealedTrait3[A, A1, A2, A3], SealedTrait4[A, A1, A2, A3, A4], SealedTrait5[A, A1, A2, A3, A4, A5], SealedTrait6[A, A1, A2, A3, A4, A5, A6], SealedTrait7[A, A1, A2, A3, A4, A5, A6, A7], SealedTrait8[A, A1, A2, A3, A4, A5, A6, A7, A8], SealedTrait9[A, A1, A2, A3, A4, A5, A6, A7, A8, A9], SealedTrait10[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10], SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11], SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12], SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _2[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A2) extends SealedTrait2[A, A1, A2], SealedTrait3[A, A1, A2, A3], SealedTrait4[A, A1, A2, A3, A4], SealedTrait5[A, A1, A2, A3, A4, A5], SealedTrait6[A, A1, A2, A3, A4, A5, A6], SealedTrait7[A, A1, A2, A3, A4, A5, A6, A7], SealedTrait8[A, A1, A2, A3, A4, A5, A6, A7, A8], SealedTrait9[A, A1, A2, A3, A4, A5, A6, A7, A8, A9], SealedTrait10[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10], SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11], SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12], SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _3[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A3) extends SealedTrait3[A, A1, A2, A3], SealedTrait4[A, A1, A2, A3, A4], SealedTrait5[A, A1, A2, A3, A4, A5], SealedTrait6[A, A1, A2, A3, A4, A5, A6], SealedTrait7[A, A1, A2, A3, A4, A5, A6, A7], SealedTrait8[A, A1, A2, A3, A4, A5, A6, A7, A8], SealedTrait9[A, A1, A2, A3, A4, A5, A6, A7, A8, A9], SealedTrait10[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10], SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11], SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12], SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _4[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A4) extends SealedTrait4[A, A1, A2, A3, A4], SealedTrait5[A, A1, A2, A3, A4, A5], SealedTrait6[A, A1, A2, A3, A4, A5, A6], SealedTrait7[A, A1, A2, A3, A4, A5, A6, A7], SealedTrait8[A, A1, A2, A3, A4, A5, A6, A7, A8], SealedTrait9[A, A1, A2, A3, A4, A5, A6, A7, A8, A9], SealedTrait10[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10], SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11], SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12], SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _5[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A5) extends SealedTrait5[A, A1, A2, A3, A4, A5], SealedTrait6[A, A1, A2, A3, A4, A5, A6], SealedTrait7[A, A1, A2, A3, A4, A5, A6, A7], SealedTrait8[A, A1, A2, A3, A4, A5, A6, A7, A8], SealedTrait9[A, A1, A2, A3, A4, A5, A6, A7, A8, A9], SealedTrait10[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10], SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11], SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12], SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _6[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A6) extends SealedTrait6[A, A1, A2, A3, A4, A5, A6], SealedTrait7[A, A1, A2, A3, A4, A5, A6, A7], SealedTrait8[A, A1, A2, A3, A4, A5, A6, A7, A8], SealedTrait9[A, A1, A2, A3, A4, A5, A6, A7, A8, A9], SealedTrait10[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10], SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11], SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12], SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _7[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A7) extends SealedTrait7[A, A1, A2, A3, A4, A5, A6, A7], SealedTrait8[A, A1, A2, A3, A4, A5, A6, A7, A8], SealedTrait9[A, A1, A2, A3, A4, A5, A6, A7, A8, A9], SealedTrait10[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10], SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11], SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12], SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _8[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A8) extends SealedTrait8[A, A1, A2, A3, A4, A5, A6, A7, A8], SealedTrait9[A, A1, A2, A3, A4, A5, A6, A7, A8, A9], SealedTrait10[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10], SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11], SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12], SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _9[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A9) extends SealedTrait9[A, A1, A2, A3, A4, A5, A6, A7, A8, A9], SealedTrait10[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10], SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11], SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12], SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _10[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A10) extends SealedTrait10[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10], SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11], SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12], SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _11[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A11) extends SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11], SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12], SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _12[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A12) extends SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12], SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _13[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A13) extends SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _14[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A14) extends SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _15[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A15) extends SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _16[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A16) extends SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _17[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A17) extends SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _18[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A18) extends SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _19[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A19) extends SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _20[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A20) extends SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _21[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A21) extends SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _22[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A22) extends SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _23[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A23) extends SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _24[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A24) extends SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _25[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A25) extends SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _26[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A26) extends SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _27[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A27) extends SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _28[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A28) extends SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _29[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A29) extends SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _30[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A30) extends SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _31[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A31) extends SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _32[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A32) extends SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _33[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A33) extends SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _34[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A34) extends SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _35[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A35) extends SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _36[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A36) extends SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _37[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A37) extends SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _38[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A38) extends SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _39[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A39) extends SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _40[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A40) extends SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _41[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A41) extends SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _42[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A42) extends SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _43[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A43) extends SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _44[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A44) extends SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _45[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A45) extends SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _46[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A46) extends SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _47[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A47) extends SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _48[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A48) extends SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _49[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A49) extends SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _50[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A50) extends SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _51[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A51) extends SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _52[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A52) extends SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _53[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A53) extends SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _54[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A54) extends SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _55[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A55) extends SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _56[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A56) extends SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _57[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A57) extends SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _58[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A58) extends SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _59[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A59) extends SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _60[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A60) extends SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _61[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A61) extends SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _62[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A62) extends SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _63[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A63) extends SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
+  final case class _64[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](value: A64) extends SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]
diff --git a/tests/pos/jzon/encoders.scala b/tests/pos/jzon/encoders.scala
new file mode 100644
index 000000000000..eded37314d50
--- /dev/null
+++ b/tests/pos/jzon/encoders.scala
@@ -0,0 +1,2932 @@
+trait Meta[T]
+trait Lazy[T]{
+  lazy val value: T = ???
+}
+trait Encoder[A] { self =>
+  def unsafeEncode(a: A, indent: Option[Int], out: java.io.Writer): Unit = ???
+}
+abstract class SealedTraitEncoder[A, ST <: SealedTrait[A]](subs: Array[Meta[?]]) extends Encoder[ST] {
+  def unsafeEncodeValue(st: ST, indent: Option[Int], out: java.io.Writer): Unit
+  final override def unsafeEncode(st: ST, indent: Option[Int], out: java.io.Writer): Unit = ???
+}
+abstract class SealedTraitDiscrimEncoder[A, ST <: SealedTrait[A]](
+  subs: Array[Meta[?]],
+  hintfield: String
+) extends Encoder[ST] {
+  def unsafeEncodeValue(st: ST, indent: Option[Int], out: java.io.Writer): Unit
+  final override def unsafeEncode(st: ST, indent: Option[Int], out: java.io.Writer): Unit = ???
+}
+
+object Encoders{
+ implicit def sealedtrait1[A, A1 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]]): Encoder[SealedTrait1[A, A1]] = {
+    def work(st: SealedTrait1[A, A1], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait1[A, A1]](Array(M1)) {
+        override def unsafeEncodeValue(st: SealedTrait1[A, A1], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait1[A, A1]](Array(M1), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait1[A, A1], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait2[A, A1 <: A, A2 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]]): Encoder[SealedTrait2[A, A1, A2]] = {
+    def work(st: SealedTrait2[A, A1, A2], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait2[A, A1, A2]](Array(M1, M2)) {
+        override def unsafeEncodeValue(st: SealedTrait2[A, A1, A2], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait2[A, A1, A2]](Array(M1, M2), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait2[A, A1, A2], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait3[A, A1 <: A, A2 <: A, A3 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]]): Encoder[SealedTrait3[A, A1, A2, A3]] = {
+    def work(st: SealedTrait3[A, A1, A2, A3], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait3[A, A1, A2, A3]](Array(M1, M2, M3)) {
+        override def unsafeEncodeValue(st: SealedTrait3[A, A1, A2, A3], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait3[A, A1, A2, A3]](Array(M1, M2, M3), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait3[A, A1, A2, A3], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait4[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]]): Encoder[SealedTrait4[A, A1, A2, A3, A4]] = {
+    def work(st: SealedTrait4[A, A1, A2, A3, A4], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait4[A, A1, A2, A3, A4]](Array(M1, M2, M3, M4)) {
+        override def unsafeEncodeValue(st: SealedTrait4[A, A1, A2, A3, A4], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait4[A, A1, A2, A3, A4]](Array(M1, M2, M3, M4), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait4[A, A1, A2, A3, A4], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait5[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]]): Encoder[SealedTrait5[A, A1, A2, A3, A4, A5]] = {
+    def work(st: SealedTrait5[A, A1, A2, A3, A4, A5], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait5[A, A1, A2, A3, A4, A5]](Array(M1, M2, M3, M4, M5)) {
+        override def unsafeEncodeValue(st: SealedTrait5[A, A1, A2, A3, A4, A5], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait5[A, A1, A2, A3, A4, A5]](Array(M1, M2, M3, M4, M5), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait5[A, A1, A2, A3, A4, A5], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait6[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]]): Encoder[SealedTrait6[A, A1, A2, A3, A4, A5, A6]] = {
+    def work(st: SealedTrait6[A, A1, A2, A3, A4, A5, A6], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait6[A, A1, A2, A3, A4, A5, A6]](Array(M1, M2, M3, M4, M5, M6)) {
+        override def unsafeEncodeValue(st: SealedTrait6[A, A1, A2, A3, A4, A5, A6], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait6[A, A1, A2, A3, A4, A5, A6]](Array(M1, M2, M3, M4, M5, M6), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait6[A, A1, A2, A3, A4, A5, A6], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait7[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]]): Encoder[SealedTrait7[A, A1, A2, A3, A4, A5, A6, A7]] = {
+    def work(st: SealedTrait7[A, A1, A2, A3, A4, A5, A6, A7], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait7[A, A1, A2, A3, A4, A5, A6, A7]](Array(M1, M2, M3, M4, M5, M6, M7)) {
+        override def unsafeEncodeValue(st: SealedTrait7[A, A1, A2, A3, A4, A5, A6, A7], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait7[A, A1, A2, A3, A4, A5, A6, A7]](Array(M1, M2, M3, M4, M5, M6, M7), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait7[A, A1, A2, A3, A4, A5, A6, A7], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait8[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]]): Encoder[SealedTrait8[A, A1, A2, A3, A4, A5, A6, A7, A8]] = {
+    def work(st: SealedTrait8[A, A1, A2, A3, A4, A5, A6, A7, A8], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait8[A, A1, A2, A3, A4, A5, A6, A7, A8]](Array(M1, M2, M3, M4, M5, M6, M7, M8)) {
+        override def unsafeEncodeValue(st: SealedTrait8[A, A1, A2, A3, A4, A5, A6, A7, A8], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait8[A, A1, A2, A3, A4, A5, A6, A7, A8]](Array(M1, M2, M3, M4, M5, M6, M7, M8), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait8[A, A1, A2, A3, A4, A5, A6, A7, A8], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait9[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]]): Encoder[SealedTrait9[A, A1, A2, A3, A4, A5, A6, A7, A8, A9]] = {
+    def work(st: SealedTrait9[A, A1, A2, A3, A4, A5, A6, A7, A8, A9], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait9[A, A1, A2, A3, A4, A5, A6, A7, A8, A9]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9)) {
+        override def unsafeEncodeValue(st: SealedTrait9[A, A1, A2, A3, A4, A5, A6, A7, A8, A9], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait9[A, A1, A2, A3, A4, A5, A6, A7, A8, A9]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait9[A, A1, A2, A3, A4, A5, A6, A7, A8, A9], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait10[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]]): Encoder[SealedTrait10[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]] = {
+    def work(st: SealedTrait10[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait10[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10)) {
+        override def unsafeEncodeValue(st: SealedTrait10[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait10[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait10[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait11[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]]): Encoder[SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]] = {
+    def work(st: SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11)) {
+        override def unsafeEncodeValue(st: SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait11[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait12[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]]): Encoder[SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]] = {
+    def work(st: SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12)) {
+        override def unsafeEncodeValue(st: SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait12[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait13[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]]): Encoder[SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]] = {
+    def work(st: SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13)) {
+        override def unsafeEncodeValue(st: SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait13[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait14[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]]): Encoder[SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]] = {
+    def work(st: SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14)) {
+        override def unsafeEncodeValue(st: SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait14[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait15[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]]): Encoder[SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]] = {
+    def work(st: SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15)) {
+        override def unsafeEncodeValue(st: SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait15[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait16[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]]): Encoder[SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]] = {
+    def work(st: SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16)) {
+        override def unsafeEncodeValue(st: SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait16[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait17[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]]): Encoder[SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17]] = {
+    def work(st: SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17)) {
+        override def unsafeEncodeValue(st: SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait17[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait18[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]]): Encoder[SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18]] = {
+    def work(st: SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18)) {
+        override def unsafeEncodeValue(st: SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait18[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait19[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]]): Encoder[SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19]] = {
+    def work(st: SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19)) {
+        override def unsafeEncodeValue(st: SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait19[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait20[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]]): Encoder[SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20]] = {
+    def work(st: SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20)) {
+        override def unsafeEncodeValue(st: SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait20[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait21[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]]): Encoder[SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21]] = {
+    def work(st: SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21)) {
+        override def unsafeEncodeValue(st: SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait21[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait22[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]]): Encoder[SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22]] = {
+    def work(st: SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22)) {
+        override def unsafeEncodeValue(st: SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait22[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait23[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]]): Encoder[SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23]] = {
+    def work(st: SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23)) {
+        override def unsafeEncodeValue(st: SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait23[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait24[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]]): Encoder[SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24]] = {
+    def work(st: SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24)) {
+        override def unsafeEncodeValue(st: SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait24[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait25[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]]): Encoder[SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25]] = {
+    def work(st: SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25)) {
+        override def unsafeEncodeValue(st: SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait25[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait26[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]]): Encoder[SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26]] = {
+    def work(st: SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26)) {
+        override def unsafeEncodeValue(st: SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait26[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait27[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]]): Encoder[SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27]] = {
+    def work(st: SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27)) {
+        override def unsafeEncodeValue(st: SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait27[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait28[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]]): Encoder[SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28]] = {
+    def work(st: SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28)) {
+        override def unsafeEncodeValue(st: SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait28[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait29[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]]): Encoder[SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29]] = {
+    def work(st: SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29)) {
+        override def unsafeEncodeValue(st: SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait29[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait30[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]]): Encoder[SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30]] = {
+    def work(st: SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30)) {
+        override def unsafeEncodeValue(st: SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait30[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait31[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]]): Encoder[SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31]] = {
+    def work(st: SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31)) {
+        override def unsafeEncodeValue(st: SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait31[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait32[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]]): Encoder[SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32]] = {
+    def work(st: SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32)) {
+        override def unsafeEncodeValue(st: SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait32[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait33[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]]): Encoder[SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33]] = {
+    def work(st: SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33)) {
+        override def unsafeEncodeValue(st: SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait33[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait34[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]]): Encoder[SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34]] = {
+    def work(st: SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34)) {
+        override def unsafeEncodeValue(st: SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait34[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait35[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]]): Encoder[SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35]] = {
+    def work(st: SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35)) {
+        override def unsafeEncodeValue(st: SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait35[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait36[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]]): Encoder[SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36]] = {
+    def work(st: SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36)) {
+        override def unsafeEncodeValue(st: SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait36[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait37[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]]): Encoder[SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37]] = {
+    def work(st: SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37)) {
+        override def unsafeEncodeValue(st: SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait37[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait38[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]]): Encoder[SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38]] = {
+    def work(st: SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38)) {
+        override def unsafeEncodeValue(st: SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait38[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait39[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]]): Encoder[SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39]] = {
+    def work(st: SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39)) {
+        override def unsafeEncodeValue(st: SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait39[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait40[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]]): Encoder[SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40]] = {
+    def work(st: SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40)) {
+        override def unsafeEncodeValue(st: SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait40[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait41[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]]): Encoder[SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41]] = {
+    def work(st: SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41)) {
+        override def unsafeEncodeValue(st: SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait41[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait42[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]]): Encoder[SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42]] = {
+    def work(st: SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42)) {
+        override def unsafeEncodeValue(st: SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait42[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait43[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]]): Encoder[SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43]] = {
+    def work(st: SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43)) {
+        override def unsafeEncodeValue(st: SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait43[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait44[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]]): Encoder[SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44]] = {
+    def work(st: SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44)) {
+        override def unsafeEncodeValue(st: SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait44[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait45[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]]): Encoder[SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45]] = {
+    def work(st: SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45)) {
+        override def unsafeEncodeValue(st: SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait45[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait46[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]]): Encoder[SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46]] = {
+    def work(st: SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46)) {
+        override def unsafeEncodeValue(st: SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait46[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait47[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]]): Encoder[SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47]] = {
+    def work(st: SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47)) {
+        override def unsafeEncodeValue(st: SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait47[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait48[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]]): Encoder[SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48]] = {
+    def work(st: SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48)) {
+        override def unsafeEncodeValue(st: SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait48[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait49[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]], M49: Meta[A49], A49: Lazy[Encoder[A49]]): Encoder[SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49]] = {
+    def work(st: SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+      case SealedTrait._49(v) => A49.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49)) {
+        override def unsafeEncodeValue(st: SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait49[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait50[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]], M49: Meta[A49], A49: Lazy[Encoder[A49]], M50: Meta[A50], A50: Lazy[Encoder[A50]]): Encoder[SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50]] = {
+    def work(st: SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+      case SealedTrait._49(v) => A49.value.unsafeEncode(v, indent, out)
+      case SealedTrait._50(v) => A50.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50)) {
+        override def unsafeEncodeValue(st: SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait50[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait51[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]], M49: Meta[A49], A49: Lazy[Encoder[A49]], M50: Meta[A50], A50: Lazy[Encoder[A50]], M51: Meta[A51], A51: Lazy[Encoder[A51]]): Encoder[SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51]] = {
+    def work(st: SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+      case SealedTrait._49(v) => A49.value.unsafeEncode(v, indent, out)
+      case SealedTrait._50(v) => A50.value.unsafeEncode(v, indent, out)
+      case SealedTrait._51(v) => A51.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51)) {
+        override def unsafeEncodeValue(st: SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait51[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait52[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]], M49: Meta[A49], A49: Lazy[Encoder[A49]], M50: Meta[A50], A50: Lazy[Encoder[A50]], M51: Meta[A51], A51: Lazy[Encoder[A51]], M52: Meta[A52], A52: Lazy[Encoder[A52]]): Encoder[SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52]] = {
+    def work(st: SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+      case SealedTrait._49(v) => A49.value.unsafeEncode(v, indent, out)
+      case SealedTrait._50(v) => A50.value.unsafeEncode(v, indent, out)
+      case SealedTrait._51(v) => A51.value.unsafeEncode(v, indent, out)
+      case SealedTrait._52(v) => A52.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52)) {
+        override def unsafeEncodeValue(st: SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait52[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait53[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]], M49: Meta[A49], A49: Lazy[Encoder[A49]], M50: Meta[A50], A50: Lazy[Encoder[A50]], M51: Meta[A51], A51: Lazy[Encoder[A51]], M52: Meta[A52], A52: Lazy[Encoder[A52]], M53: Meta[A53], A53: Lazy[Encoder[A53]]): Encoder[SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53]] = {
+    def work(st: SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+      case SealedTrait._49(v) => A49.value.unsafeEncode(v, indent, out)
+      case SealedTrait._50(v) => A50.value.unsafeEncode(v, indent, out)
+      case SealedTrait._51(v) => A51.value.unsafeEncode(v, indent, out)
+      case SealedTrait._52(v) => A52.value.unsafeEncode(v, indent, out)
+      case SealedTrait._53(v) => A53.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53)) {
+        override def unsafeEncodeValue(st: SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait53[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait54[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]], M49: Meta[A49], A49: Lazy[Encoder[A49]], M50: Meta[A50], A50: Lazy[Encoder[A50]], M51: Meta[A51], A51: Lazy[Encoder[A51]], M52: Meta[A52], A52: Lazy[Encoder[A52]], M53: Meta[A53], A53: Lazy[Encoder[A53]], M54: Meta[A54], A54: Lazy[Encoder[A54]]): Encoder[SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54]] = {
+    def work(st: SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+      case SealedTrait._49(v) => A49.value.unsafeEncode(v, indent, out)
+      case SealedTrait._50(v) => A50.value.unsafeEncode(v, indent, out)
+      case SealedTrait._51(v) => A51.value.unsafeEncode(v, indent, out)
+      case SealedTrait._52(v) => A52.value.unsafeEncode(v, indent, out)
+      case SealedTrait._53(v) => A53.value.unsafeEncode(v, indent, out)
+      case SealedTrait._54(v) => A54.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54)) {
+        override def unsafeEncodeValue(st: SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait54[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait55[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]], M49: Meta[A49], A49: Lazy[Encoder[A49]], M50: Meta[A50], A50: Lazy[Encoder[A50]], M51: Meta[A51], A51: Lazy[Encoder[A51]], M52: Meta[A52], A52: Lazy[Encoder[A52]], M53: Meta[A53], A53: Lazy[Encoder[A53]], M54: Meta[A54], A54: Lazy[Encoder[A54]], M55: Meta[A55], A55: Lazy[Encoder[A55]]): Encoder[SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55]] = {
+    def work(st: SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+      case SealedTrait._49(v) => A49.value.unsafeEncode(v, indent, out)
+      case SealedTrait._50(v) => A50.value.unsafeEncode(v, indent, out)
+      case SealedTrait._51(v) => A51.value.unsafeEncode(v, indent, out)
+      case SealedTrait._52(v) => A52.value.unsafeEncode(v, indent, out)
+      case SealedTrait._53(v) => A53.value.unsafeEncode(v, indent, out)
+      case SealedTrait._54(v) => A54.value.unsafeEncode(v, indent, out)
+      case SealedTrait._55(v) => A55.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55)) {
+        override def unsafeEncodeValue(st: SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait55[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait56[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]], M49: Meta[A49], A49: Lazy[Encoder[A49]], M50: Meta[A50], A50: Lazy[Encoder[A50]], M51: Meta[A51], A51: Lazy[Encoder[A51]], M52: Meta[A52], A52: Lazy[Encoder[A52]], M53: Meta[A53], A53: Lazy[Encoder[A53]], M54: Meta[A54], A54: Lazy[Encoder[A54]], M55: Meta[A55], A55: Lazy[Encoder[A55]], M56: Meta[A56], A56: Lazy[Encoder[A56]]): Encoder[SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56]] = {
+    def work(st: SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+      case SealedTrait._49(v) => A49.value.unsafeEncode(v, indent, out)
+      case SealedTrait._50(v) => A50.value.unsafeEncode(v, indent, out)
+      case SealedTrait._51(v) => A51.value.unsafeEncode(v, indent, out)
+      case SealedTrait._52(v) => A52.value.unsafeEncode(v, indent, out)
+      case SealedTrait._53(v) => A53.value.unsafeEncode(v, indent, out)
+      case SealedTrait._54(v) => A54.value.unsafeEncode(v, indent, out)
+      case SealedTrait._55(v) => A55.value.unsafeEncode(v, indent, out)
+      case SealedTrait._56(v) => A56.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56)) {
+        override def unsafeEncodeValue(st: SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait56[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait57[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]], M49: Meta[A49], A49: Lazy[Encoder[A49]], M50: Meta[A50], A50: Lazy[Encoder[A50]], M51: Meta[A51], A51: Lazy[Encoder[A51]], M52: Meta[A52], A52: Lazy[Encoder[A52]], M53: Meta[A53], A53: Lazy[Encoder[A53]], M54: Meta[A54], A54: Lazy[Encoder[A54]], M55: Meta[A55], A55: Lazy[Encoder[A55]], M56: Meta[A56], A56: Lazy[Encoder[A56]], M57: Meta[A57], A57: Lazy[Encoder[A57]]): Encoder[SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57]] = {
+    def work(st: SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+      case SealedTrait._49(v) => A49.value.unsafeEncode(v, indent, out)
+      case SealedTrait._50(v) => A50.value.unsafeEncode(v, indent, out)
+      case SealedTrait._51(v) => A51.value.unsafeEncode(v, indent, out)
+      case SealedTrait._52(v) => A52.value.unsafeEncode(v, indent, out)
+      case SealedTrait._53(v) => A53.value.unsafeEncode(v, indent, out)
+      case SealedTrait._54(v) => A54.value.unsafeEncode(v, indent, out)
+      case SealedTrait._55(v) => A55.value.unsafeEncode(v, indent, out)
+      case SealedTrait._56(v) => A56.value.unsafeEncode(v, indent, out)
+      case SealedTrait._57(v) => A57.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56, M57)) {
+        override def unsafeEncodeValue(st: SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56, M57), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait57[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait58[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]], M49: Meta[A49], A49: Lazy[Encoder[A49]], M50: Meta[A50], A50: Lazy[Encoder[A50]], M51: Meta[A51], A51: Lazy[Encoder[A51]], M52: Meta[A52], A52: Lazy[Encoder[A52]], M53: Meta[A53], A53: Lazy[Encoder[A53]], M54: Meta[A54], A54: Lazy[Encoder[A54]], M55: Meta[A55], A55: Lazy[Encoder[A55]], M56: Meta[A56], A56: Lazy[Encoder[A56]], M57: Meta[A57], A57: Lazy[Encoder[A57]], M58: Meta[A58], A58: Lazy[Encoder[A58]]): Encoder[SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58]] = {
+    def work(st: SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+      case SealedTrait._49(v) => A49.value.unsafeEncode(v, indent, out)
+      case SealedTrait._50(v) => A50.value.unsafeEncode(v, indent, out)
+      case SealedTrait._51(v) => A51.value.unsafeEncode(v, indent, out)
+      case SealedTrait._52(v) => A52.value.unsafeEncode(v, indent, out)
+      case SealedTrait._53(v) => A53.value.unsafeEncode(v, indent, out)
+      case SealedTrait._54(v) => A54.value.unsafeEncode(v, indent, out)
+      case SealedTrait._55(v) => A55.value.unsafeEncode(v, indent, out)
+      case SealedTrait._56(v) => A56.value.unsafeEncode(v, indent, out)
+      case SealedTrait._57(v) => A57.value.unsafeEncode(v, indent, out)
+      case SealedTrait._58(v) => A58.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56, M57, M58)) {
+        override def unsafeEncodeValue(st: SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56, M57, M58), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait58[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait59[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]], M49: Meta[A49], A49: Lazy[Encoder[A49]], M50: Meta[A50], A50: Lazy[Encoder[A50]], M51: Meta[A51], A51: Lazy[Encoder[A51]], M52: Meta[A52], A52: Lazy[Encoder[A52]], M53: Meta[A53], A53: Lazy[Encoder[A53]], M54: Meta[A54], A54: Lazy[Encoder[A54]], M55: Meta[A55], A55: Lazy[Encoder[A55]], M56: Meta[A56], A56: Lazy[Encoder[A56]], M57: Meta[A57], A57: Lazy[Encoder[A57]], M58: Meta[A58], A58: Lazy[Encoder[A58]], M59: Meta[A59], A59: Lazy[Encoder[A59]]): Encoder[SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59]] = {
+    def work(st: SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+      case SealedTrait._49(v) => A49.value.unsafeEncode(v, indent, out)
+      case SealedTrait._50(v) => A50.value.unsafeEncode(v, indent, out)
+      case SealedTrait._51(v) => A51.value.unsafeEncode(v, indent, out)
+      case SealedTrait._52(v) => A52.value.unsafeEncode(v, indent, out)
+      case SealedTrait._53(v) => A53.value.unsafeEncode(v, indent, out)
+      case SealedTrait._54(v) => A54.value.unsafeEncode(v, indent, out)
+      case SealedTrait._55(v) => A55.value.unsafeEncode(v, indent, out)
+      case SealedTrait._56(v) => A56.value.unsafeEncode(v, indent, out)
+      case SealedTrait._57(v) => A57.value.unsafeEncode(v, indent, out)
+      case SealedTrait._58(v) => A58.value.unsafeEncode(v, indent, out)
+      case SealedTrait._59(v) => A59.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56, M57, M58, M59)) {
+        override def unsafeEncodeValue(st: SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56, M57, M58, M59), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait59[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait60[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]], M49: Meta[A49], A49: Lazy[Encoder[A49]], M50: Meta[A50], A50: Lazy[Encoder[A50]], M51: Meta[A51], A51: Lazy[Encoder[A51]], M52: Meta[A52], A52: Lazy[Encoder[A52]], M53: Meta[A53], A53: Lazy[Encoder[A53]], M54: Meta[A54], A54: Lazy[Encoder[A54]], M55: Meta[A55], A55: Lazy[Encoder[A55]], M56: Meta[A56], A56: Lazy[Encoder[A56]], M57: Meta[A57], A57: Lazy[Encoder[A57]], M58: Meta[A58], A58: Lazy[Encoder[A58]], M59: Meta[A59], A59: Lazy[Encoder[A59]], M60: Meta[A60], A60: Lazy[Encoder[A60]]): Encoder[SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60]] = {
+    def work(st: SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+      case SealedTrait._49(v) => A49.value.unsafeEncode(v, indent, out)
+      case SealedTrait._50(v) => A50.value.unsafeEncode(v, indent, out)
+      case SealedTrait._51(v) => A51.value.unsafeEncode(v, indent, out)
+      case SealedTrait._52(v) => A52.value.unsafeEncode(v, indent, out)
+      case SealedTrait._53(v) => A53.value.unsafeEncode(v, indent, out)
+      case SealedTrait._54(v) => A54.value.unsafeEncode(v, indent, out)
+      case SealedTrait._55(v) => A55.value.unsafeEncode(v, indent, out)
+      case SealedTrait._56(v) => A56.value.unsafeEncode(v, indent, out)
+      case SealedTrait._57(v) => A57.value.unsafeEncode(v, indent, out)
+      case SealedTrait._58(v) => A58.value.unsafeEncode(v, indent, out)
+      case SealedTrait._59(v) => A59.value.unsafeEncode(v, indent, out)
+      case SealedTrait._60(v) => A60.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56, M57, M58, M59, M60)) {
+        override def unsafeEncodeValue(st: SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56, M57, M58, M59, M60), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait60[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait61[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]], M49: Meta[A49], A49: Lazy[Encoder[A49]], M50: Meta[A50], A50: Lazy[Encoder[A50]], M51: Meta[A51], A51: Lazy[Encoder[A51]], M52: Meta[A52], A52: Lazy[Encoder[A52]], M53: Meta[A53], A53: Lazy[Encoder[A53]], M54: Meta[A54], A54: Lazy[Encoder[A54]], M55: Meta[A55], A55: Lazy[Encoder[A55]], M56: Meta[A56], A56: Lazy[Encoder[A56]], M57: Meta[A57], A57: Lazy[Encoder[A57]], M58: Meta[A58], A58: Lazy[Encoder[A58]], M59: Meta[A59], A59: Lazy[Encoder[A59]], M60: Meta[A60], A60: Lazy[Encoder[A60]], M61: Meta[A61], A61: Lazy[Encoder[A61]]): Encoder[SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61]] = {
+    def work(st: SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+      case SealedTrait._49(v) => A49.value.unsafeEncode(v, indent, out)
+      case SealedTrait._50(v) => A50.value.unsafeEncode(v, indent, out)
+      case SealedTrait._51(v) => A51.value.unsafeEncode(v, indent, out)
+      case SealedTrait._52(v) => A52.value.unsafeEncode(v, indent, out)
+      case SealedTrait._53(v) => A53.value.unsafeEncode(v, indent, out)
+      case SealedTrait._54(v) => A54.value.unsafeEncode(v, indent, out)
+      case SealedTrait._55(v) => A55.value.unsafeEncode(v, indent, out)
+      case SealedTrait._56(v) => A56.value.unsafeEncode(v, indent, out)
+      case SealedTrait._57(v) => A57.value.unsafeEncode(v, indent, out)
+      case SealedTrait._58(v) => A58.value.unsafeEncode(v, indent, out)
+      case SealedTrait._59(v) => A59.value.unsafeEncode(v, indent, out)
+      case SealedTrait._60(v) => A60.value.unsafeEncode(v, indent, out)
+      case SealedTrait._61(v) => A61.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56, M57, M58, M59, M60, M61)) {
+        override def unsafeEncodeValue(st: SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56, M57, M58, M59, M60, M61), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait61[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait62[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]], M49: Meta[A49], A49: Lazy[Encoder[A49]], M50: Meta[A50], A50: Lazy[Encoder[A50]], M51: Meta[A51], A51: Lazy[Encoder[A51]], M52: Meta[A52], A52: Lazy[Encoder[A52]], M53: Meta[A53], A53: Lazy[Encoder[A53]], M54: Meta[A54], A54: Lazy[Encoder[A54]], M55: Meta[A55], A55: Lazy[Encoder[A55]], M56: Meta[A56], A56: Lazy[Encoder[A56]], M57: Meta[A57], A57: Lazy[Encoder[A57]], M58: Meta[A58], A58: Lazy[Encoder[A58]], M59: Meta[A59], A59: Lazy[Encoder[A59]], M60: Meta[A60], A60: Lazy[Encoder[A60]], M61: Meta[A61], A61: Lazy[Encoder[A61]], M62: Meta[A62], A62: Lazy[Encoder[A62]]): Encoder[SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62]] = {
+    def work(st: SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+      case SealedTrait._49(v) => A49.value.unsafeEncode(v, indent, out)
+      case SealedTrait._50(v) => A50.value.unsafeEncode(v, indent, out)
+      case SealedTrait._51(v) => A51.value.unsafeEncode(v, indent, out)
+      case SealedTrait._52(v) => A52.value.unsafeEncode(v, indent, out)
+      case SealedTrait._53(v) => A53.value.unsafeEncode(v, indent, out)
+      case SealedTrait._54(v) => A54.value.unsafeEncode(v, indent, out)
+      case SealedTrait._55(v) => A55.value.unsafeEncode(v, indent, out)
+      case SealedTrait._56(v) => A56.value.unsafeEncode(v, indent, out)
+      case SealedTrait._57(v) => A57.value.unsafeEncode(v, indent, out)
+      case SealedTrait._58(v) => A58.value.unsafeEncode(v, indent, out)
+      case SealedTrait._59(v) => A59.value.unsafeEncode(v, indent, out)
+      case SealedTrait._60(v) => A60.value.unsafeEncode(v, indent, out)
+      case SealedTrait._61(v) => A61.value.unsafeEncode(v, indent, out)
+      case SealedTrait._62(v) => A62.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56, M57, M58, M59, M60, M61, M62)) {
+        override def unsafeEncodeValue(st: SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56, M57, M58, M59, M60, M61, M62), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait62[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait63[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]], M49: Meta[A49], A49: Lazy[Encoder[A49]], M50: Meta[A50], A50: Lazy[Encoder[A50]], M51: Meta[A51], A51: Lazy[Encoder[A51]], M52: Meta[A52], A52: Lazy[Encoder[A52]], M53: Meta[A53], A53: Lazy[Encoder[A53]], M54: Meta[A54], A54: Lazy[Encoder[A54]], M55: Meta[A55], A55: Lazy[Encoder[A55]], M56: Meta[A56], A56: Lazy[Encoder[A56]], M57: Meta[A57], A57: Lazy[Encoder[A57]], M58: Meta[A58], A58: Lazy[Encoder[A58]], M59: Meta[A59], A59: Lazy[Encoder[A59]], M60: Meta[A60], A60: Lazy[Encoder[A60]], M61: Meta[A61], A61: Lazy[Encoder[A61]], M62: Meta[A62], A62: Lazy[Encoder[A62]], M63: Meta[A63], A63: Lazy[Encoder[A63]]): Encoder[SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63]] = {
+    def work(st: SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+      case SealedTrait._49(v) => A49.value.unsafeEncode(v, indent, out)
+      case SealedTrait._50(v) => A50.value.unsafeEncode(v, indent, out)
+      case SealedTrait._51(v) => A51.value.unsafeEncode(v, indent, out)
+      case SealedTrait._52(v) => A52.value.unsafeEncode(v, indent, out)
+      case SealedTrait._53(v) => A53.value.unsafeEncode(v, indent, out)
+      case SealedTrait._54(v) => A54.value.unsafeEncode(v, indent, out)
+      case SealedTrait._55(v) => A55.value.unsafeEncode(v, indent, out)
+      case SealedTrait._56(v) => A56.value.unsafeEncode(v, indent, out)
+      case SealedTrait._57(v) => A57.value.unsafeEncode(v, indent, out)
+      case SealedTrait._58(v) => A58.value.unsafeEncode(v, indent, out)
+      case SealedTrait._59(v) => A59.value.unsafeEncode(v, indent, out)
+      case SealedTrait._60(v) => A60.value.unsafeEncode(v, indent, out)
+      case SealedTrait._61(v) => A61.value.unsafeEncode(v, indent, out)
+      case SealedTrait._62(v) => A62.value.unsafeEncode(v, indent, out)
+      case SealedTrait._63(v) => A63.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56, M57, M58, M59, M60, M61, M62, M63)) {
+        override def unsafeEncodeValue(st: SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56, M57, M58, M59, M60, M61, M62, M63), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait63[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+
+  implicit def sealedtrait64[A, A1 <: A, A2 <: A, A3 <: A, A4 <: A, A5 <: A, A6 <: A, A7 <: A, A8 <: A, A9 <: A, A10 <: A, A11 <: A, A12 <: A, A13 <: A, A14 <: A, A15 <: A, A16 <: A, A17 <: A, A18 <: A, A19 <: A, A20 <: A, A21 <: A, A22 <: A, A23 <: A, A24 <: A, A25 <: A, A26 <: A, A27 <: A, A28 <: A, A29 <: A, A30 <: A, A31 <: A, A32 <: A, A33 <: A, A34 <: A, A35 <: A, A36 <: A, A37 <: A, A38 <: A, A39 <: A, A40 <: A, A41 <: A, A42 <: A, A43 <: A, A44 <: A, A45 <: A, A46 <: A, A47 <: A, A48 <: A, A49 <: A, A50 <: A, A51 <: A, A52 <: A, A53 <: A, A54 <: A, A55 <: A, A56 <: A, A57 <: A, A58 <: A, A59 <: A, A60 <: A, A61 <: A, A62 <: A, A63 <: A, A64 <: A](implicit M: Meta[A], M1: Meta[A1], A1: Lazy[Encoder[A1]], M2: Meta[A2], A2: Lazy[Encoder[A2]], M3: Meta[A3], A3: Lazy[Encoder[A3]], M4: Meta[A4], A4: Lazy[Encoder[A4]], M5: Meta[A5], A5: Lazy[Encoder[A5]], M6: Meta[A6], A6: Lazy[Encoder[A6]], M7: Meta[A7], A7: Lazy[Encoder[A7]], M8: Meta[A8], A8: Lazy[Encoder[A8]], M9: Meta[A9], A9: Lazy[Encoder[A9]], M10: Meta[A10], A10: Lazy[Encoder[A10]], M11: Meta[A11], A11: Lazy[Encoder[A11]], M12: Meta[A12], A12: Lazy[Encoder[A12]], M13: Meta[A13], A13: Lazy[Encoder[A13]], M14: Meta[A14], A14: Lazy[Encoder[A14]], M15: Meta[A15], A15: Lazy[Encoder[A15]], M16: Meta[A16], A16: Lazy[Encoder[A16]], M17: Meta[A17], A17: Lazy[Encoder[A17]], M18: Meta[A18], A18: Lazy[Encoder[A18]], M19: Meta[A19], A19: Lazy[Encoder[A19]], M20: Meta[A20], A20: Lazy[Encoder[A20]], M21: Meta[A21], A21: Lazy[Encoder[A21]], M22: Meta[A22], A22: Lazy[Encoder[A22]], M23: Meta[A23], A23: Lazy[Encoder[A23]], M24: Meta[A24], A24: Lazy[Encoder[A24]], M25: Meta[A25], A25: Lazy[Encoder[A25]], M26: Meta[A26], A26: Lazy[Encoder[A26]], M27: Meta[A27], A27: Lazy[Encoder[A27]], M28: Meta[A28], A28: Lazy[Encoder[A28]], M29: Meta[A29], A29: Lazy[Encoder[A29]], M30: Meta[A30], A30: Lazy[Encoder[A30]], M31: Meta[A31], A31: Lazy[Encoder[A31]], M32: Meta[A32], A32: Lazy[Encoder[A32]], M33: Meta[A33], A33: Lazy[Encoder[A33]], M34: Meta[A34], A34: Lazy[Encoder[A34]], M35: Meta[A35], A35: Lazy[Encoder[A35]], M36: Meta[A36], A36: Lazy[Encoder[A36]], M37: Meta[A37], A37: Lazy[Encoder[A37]], M38: Meta[A38], A38: Lazy[Encoder[A38]], M39: Meta[A39], A39: Lazy[Encoder[A39]], M40: Meta[A40], A40: Lazy[Encoder[A40]], M41: Meta[A41], A41: Lazy[Encoder[A41]], M42: Meta[A42], A42: Lazy[Encoder[A42]], M43: Meta[A43], A43: Lazy[Encoder[A43]], M44: Meta[A44], A44: Lazy[Encoder[A44]], M45: Meta[A45], A45: Lazy[Encoder[A45]], M46: Meta[A46], A46: Lazy[Encoder[A46]], M47: Meta[A47], A47: Lazy[Encoder[A47]], M48: Meta[A48], A48: Lazy[Encoder[A48]], M49: Meta[A49], A49: Lazy[Encoder[A49]], M50: Meta[A50], A50: Lazy[Encoder[A50]], M51: Meta[A51], A51: Lazy[Encoder[A51]], M52: Meta[A52], A52: Lazy[Encoder[A52]], M53: Meta[A53], A53: Lazy[Encoder[A53]], M54: Meta[A54], A54: Lazy[Encoder[A54]], M55: Meta[A55], A55: Lazy[Encoder[A55]], M56: Meta[A56], A56: Lazy[Encoder[A56]], M57: Meta[A57], A57: Lazy[Encoder[A57]], M58: Meta[A58], A58: Lazy[Encoder[A58]], M59: Meta[A59], A59: Lazy[Encoder[A59]], M60: Meta[A60], A60: Lazy[Encoder[A60]], M61: Meta[A61], A61: Lazy[Encoder[A61]], M62: Meta[A62], A62: Lazy[Encoder[A62]], M63: Meta[A63], A63: Lazy[Encoder[A63]], M64: Meta[A64], A64: Lazy[Encoder[A64]]): Encoder[SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]] = {
+    def work(st: SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64], indent: Option[Int], out: java.io.Writer): Unit = st match {
+      case SealedTrait._1(v) => A1.value.unsafeEncode(v, indent, out)
+      case SealedTrait._2(v) => A2.value.unsafeEncode(v, indent, out)
+      case SealedTrait._3(v) => A3.value.unsafeEncode(v, indent, out)
+      case SealedTrait._4(v) => A4.value.unsafeEncode(v, indent, out)
+      case SealedTrait._5(v) => A5.value.unsafeEncode(v, indent, out)
+      case SealedTrait._6(v) => A6.value.unsafeEncode(v, indent, out)
+      case SealedTrait._7(v) => A7.value.unsafeEncode(v, indent, out)
+      case SealedTrait._8(v) => A8.value.unsafeEncode(v, indent, out)
+      case SealedTrait._9(v) => A9.value.unsafeEncode(v, indent, out)
+      case SealedTrait._10(v) => A10.value.unsafeEncode(v, indent, out)
+      case SealedTrait._11(v) => A11.value.unsafeEncode(v, indent, out)
+      case SealedTrait._12(v) => A12.value.unsafeEncode(v, indent, out)
+      case SealedTrait._13(v) => A13.value.unsafeEncode(v, indent, out)
+      case SealedTrait._14(v) => A14.value.unsafeEncode(v, indent, out)
+      case SealedTrait._15(v) => A15.value.unsafeEncode(v, indent, out)
+      case SealedTrait._16(v) => A16.value.unsafeEncode(v, indent, out)
+      case SealedTrait._17(v) => A17.value.unsafeEncode(v, indent, out)
+      case SealedTrait._18(v) => A18.value.unsafeEncode(v, indent, out)
+      case SealedTrait._19(v) => A19.value.unsafeEncode(v, indent, out)
+      case SealedTrait._20(v) => A20.value.unsafeEncode(v, indent, out)
+      case SealedTrait._21(v) => A21.value.unsafeEncode(v, indent, out)
+      case SealedTrait._22(v) => A22.value.unsafeEncode(v, indent, out)
+      case SealedTrait._23(v) => A23.value.unsafeEncode(v, indent, out)
+      case SealedTrait._24(v) => A24.value.unsafeEncode(v, indent, out)
+      case SealedTrait._25(v) => A25.value.unsafeEncode(v, indent, out)
+      case SealedTrait._26(v) => A26.value.unsafeEncode(v, indent, out)
+      case SealedTrait._27(v) => A27.value.unsafeEncode(v, indent, out)
+      case SealedTrait._28(v) => A28.value.unsafeEncode(v, indent, out)
+      case SealedTrait._29(v) => A29.value.unsafeEncode(v, indent, out)
+      case SealedTrait._30(v) => A30.value.unsafeEncode(v, indent, out)
+      case SealedTrait._31(v) => A31.value.unsafeEncode(v, indent, out)
+      case SealedTrait._32(v) => A32.value.unsafeEncode(v, indent, out)
+      case SealedTrait._33(v) => A33.value.unsafeEncode(v, indent, out)
+      case SealedTrait._34(v) => A34.value.unsafeEncode(v, indent, out)
+      case SealedTrait._35(v) => A35.value.unsafeEncode(v, indent, out)
+      case SealedTrait._36(v) => A36.value.unsafeEncode(v, indent, out)
+      case SealedTrait._37(v) => A37.value.unsafeEncode(v, indent, out)
+      case SealedTrait._38(v) => A38.value.unsafeEncode(v, indent, out)
+      case SealedTrait._39(v) => A39.value.unsafeEncode(v, indent, out)
+      case SealedTrait._40(v) => A40.value.unsafeEncode(v, indent, out)
+      case SealedTrait._41(v) => A41.value.unsafeEncode(v, indent, out)
+      case SealedTrait._42(v) => A42.value.unsafeEncode(v, indent, out)
+      case SealedTrait._43(v) => A43.value.unsafeEncode(v, indent, out)
+      case SealedTrait._44(v) => A44.value.unsafeEncode(v, indent, out)
+      case SealedTrait._45(v) => A45.value.unsafeEncode(v, indent, out)
+      case SealedTrait._46(v) => A46.value.unsafeEncode(v, indent, out)
+      case SealedTrait._47(v) => A47.value.unsafeEncode(v, indent, out)
+      case SealedTrait._48(v) => A48.value.unsafeEncode(v, indent, out)
+      case SealedTrait._49(v) => A49.value.unsafeEncode(v, indent, out)
+      case SealedTrait._50(v) => A50.value.unsafeEncode(v, indent, out)
+      case SealedTrait._51(v) => A51.value.unsafeEncode(v, indent, out)
+      case SealedTrait._52(v) => A52.value.unsafeEncode(v, indent, out)
+      case SealedTrait._53(v) => A53.value.unsafeEncode(v, indent, out)
+      case SealedTrait._54(v) => A54.value.unsafeEncode(v, indent, out)
+      case SealedTrait._55(v) => A55.value.unsafeEncode(v, indent, out)
+      case SealedTrait._56(v) => A56.value.unsafeEncode(v, indent, out)
+      case SealedTrait._57(v) => A57.value.unsafeEncode(v, indent, out)
+      case SealedTrait._58(v) => A58.value.unsafeEncode(v, indent, out)
+      case SealedTrait._59(v) => A59.value.unsafeEncode(v, indent, out)
+      case SealedTrait._60(v) => A60.value.unsafeEncode(v, indent, out)
+      case SealedTrait._61(v) => A61.value.unsafeEncode(v, indent, out)
+      case SealedTrait._62(v) => A62.value.unsafeEncode(v, indent, out)
+      case SealedTrait._63(v) => A63.value.unsafeEncode(v, indent, out)
+      case SealedTrait._64(v) => A64.value.unsafeEncode(v, indent, out)
+    }
+    Option("hintname") match {
+      case None => new SealedTraitEncoder[A, SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56, M57, M58, M59, M60, M61, M62, M63, M64)) {
+        override def unsafeEncodeValue(st: SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+      case Some(hintfield) => new SealedTraitDiscrimEncoder[A, SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64]](Array(M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11, M12, M13, M14, M15, M16, M17, M18, M19, M20, M21, M22, M23, M24, M25, M26, M27, M28, M29, M30, M31, M32, M33, M34, M35, M36, M37, M38, M39, M40, M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54, M55, M56, M57, M58, M59, M60, M61, M62, M63, M64), hintfield) {
+        override def unsafeEncodeValue(st: SealedTrait64[A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64], indent: Option[Int], out: java.io.Writer): Unit = work(st, indent, out)
+      }
+    }
+  }
+}

From 3458da724bd35b226b39c670be76d55ee13b4033 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 16 Oct 2024 20:35:17 +0100
Subject: [PATCH 037/306] Add Show[Long] & Show[Unit]

---
 compiler/src/dotty/tools/dotc/printing/Formatting.scala | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/compiler/src/dotty/tools/dotc/printing/Formatting.scala b/compiler/src/dotty/tools/dotc/printing/Formatting.scala
index a36e6f48533a..bf3ca23c407b 100644
--- a/compiler/src/dotty/tools/dotc/printing/Formatting.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Formatting.scala
@@ -115,6 +115,7 @@ object Formatting {
       given Show[Char]                                = ShowAny
       given Show[Boolean]                             = ShowAny
       given Show[Integer]                             = ShowAny
+      given Show[Long]                                = ShowAny
       given Show[String]                              = ShowAny
       given Show[Class[?]]                            = ShowAny
       given Show[Throwable]                           = ShowAny
@@ -122,6 +123,7 @@ object Formatting {
       given Show[CompilationUnit]                     = ShowAny
       given Show[Phases.Phase]                        = ShowAny
       given Show[TyperState]                          = ShowAny
+      given Show[Unit]                                = ShowAny
       given Show[config.ScalaVersion]                 = ShowAny
       given Show[io.AbstractFile]                     = ShowAny
       given Show[parsing.Scanners.Scanner]            = ShowAny

From 8d612de7b0e9a07711db86e6cbc1a7e04194b847 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 16 Oct 2024 20:35:54 +0100
Subject: [PATCH 038/306] Add a >0.1s timer to trace

---
 compiler/src/dotty/tools/dotc/reporting/trace.scala      | 9 ++++++++-
 .../src/dotty/tools/dotc/typer/ImportSuggestions.scala   | 2 +-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/reporting/trace.scala b/compiler/src/dotty/tools/dotc/reporting/trace.scala
index 732e779e9bf7..7f05cffb422a 100644
--- a/compiler/src/dotty/tools/dotc/reporting/trace.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/trace.scala
@@ -96,6 +96,7 @@ trait TraceSyntax:
                         (op: => T)(using Context): T =
     if ctx.mode.is(Mode.Printing) || !isForced && (printer eq Printers.noPrinter) then op
     else
+      val start = System.nanoTime
       // Avoid evaluating question multiple time, since each evaluation
       // may cause some extra logging output.
       val q = question
@@ -109,7 +110,13 @@ trait TraceSyntax:
       def finalize(msg: String) =
         if !finalized then
           ctx.base.indent -= 1
-          doLog(s"$margin$msg")
+          val stop = System.nanoTime
+          val diffNs = stop - start
+          val diffS = (diffNs / 1000 / 1000).toInt / 1000.0
+          if diffS > 0.1 then
+            doLog(s"$margin$msg (${"%.2f".format(diffS)} s)")
+          else
+            doLog(s"$margin$msg")
           finalized = true
       try
         doLog(s"$margin$leading")
diff --git a/compiler/src/dotty/tools/dotc/typer/ImportSuggestions.scala b/compiler/src/dotty/tools/dotc/typer/ImportSuggestions.scala
index 8f8c51e2f566..3ae533d58b2e 100644
--- a/compiler/src/dotty/tools/dotc/typer/ImportSuggestions.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ImportSuggestions.scala
@@ -264,7 +264,7 @@ trait ImportSuggestions:
   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.
+   *  for current search, but never less than to half of the previous budget.
    */
   private def reduceTimeBudget(used: Int)(using Context) =
     val run = ctx.run.nn

From 28b8c55595dd86351aaac234a270c878f8236730 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 16 Oct 2024 13:03:49 +0100
Subject: [PATCH 039/306] Optimise refineUsingParent to use constrained

Using `constrained` on a TypeLambda means adding one TypeLambda for all
the type parameters in tp1, while newTypeVar creates a TypeLambda for
each type parameter.
---
 compiler/src/dotty/tools/dotc/core/TypeOps.scala |  4 +++-
 compiler/src/dotty/tools/dotc/core/Types.scala   | 10 +++++++---
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
index bfda613d0586..5b5086f065e9 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -902,7 +902,9 @@ object TypeOps:
     }
 
     val inferThisMap = new InferPrefixMap
-    val tvars = tp1.typeParams.map { tparam => newTypeVar(tparam.paramInfo.bounds, DepParamName.fresh(tparam.paramName)) }
+    val tvars = tp1.etaExpand match
+      case eta: TypeLambda => constrained(eta)
+      case _               => Nil
     val protoTp1 = inferThisMap.apply(tp1).appliedTo(tvars)
 
     if gadtSyms.nonEmpty then
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index cf73bda0d131..2eecc717e940 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -4395,9 +4395,11 @@ object Types extends TypeUtils {
 
     /** 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)
+     *  {{{
+     *      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
@@ -4409,6 +4411,7 @@ object Types extends TypeUtils {
      *
      *  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)
@@ -4416,6 +4419,7 @@ object Types extends TypeUtils {
      *    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) =

From bdafee6a0e2de44b58839c1eb9c357eee809d4ad Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 16 Oct 2024 15:15:03 +0100
Subject: [PATCH 040/306] Optimise SpaceEngine.signature for synthetic
 unapplies

Instead of creating type vars, constraining against them, then
instantiating them, just instantiate the PolyType with the scrutinee
type args (or the lo/hi bound or bounded wildcard from the param).
---
 .../src/dotty/tools/dotc/core/Types.scala     |  1 +
 .../tools/dotc/transform/patmat/Space.scala   | 32 ++++++++++++++++---
 2 files changed, 28 insertions(+), 5 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 2eecc717e940..e1f253941a45 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -4706,6 +4706,7 @@ object Types extends TypeUtils {
     type BT <: LambdaType
     def paramNum: Int
     def paramName: binder.ThisName = binder.paramNames(paramNum)
+    def paramInfo: binder.PInfo    = binder.paramInfos(paramNum)
 
     override def underlying(using Context): Type = {
       // TODO: update paramInfos's type to nullable
diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 20b0099d82e2..af37135e5196 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -7,7 +7,7 @@ import core.*
 import Constants.*, Contexts.*, Decorators.*, Flags.*, NullOpsDecorator.*, Symbols.*, Types.*
 import Names.*, NameOps.*, StdNames.*
 import ast.*, tpd.*
-import config.Printers.*
+import config.Printers.exhaustivity
 import printing.{ Printer, * }, Texts.*
 import reporting.*
 import typer.*, Applications.*, Inferencing.*, ProtoTypes.*
@@ -524,14 +524,36 @@ object SpaceEngine {
     val mt: MethodType = unapp.widen match {
       case mt: MethodType => mt
       case pt: PolyType   =>
+        if unappSym.is(Synthetic) then
+          val mt = pt.resultType.asInstanceOf[MethodType]
+          val unapplyArgType = mt.paramInfos.head
+          val targs = scrutineeTp.baseType(unapplyArgType.classSymbol) match
+            case AppliedType(_, targs) => targs
+            case _ =>
+              // Typically when the scrutinee is Null or Nothing (see i5067 and i5067b)
+              // For performance, do `variances(unapplyArgType)` but without using TypeVars
+              // so just find the variance, so we know if to min/max to the LB/UB or use a wildcard.
+              object accu extends TypeAccumulator[VarianceMap[TypeParamRef]]:
+                def apply(vmap: VarianceMap[TypeParamRef], tp: Type) = tp match
+                  case tp: TypeParamRef if tp.binder eq pt => vmap.recordLocalVariance(tp, variance)
+                  case _                                   => foldOver(vmap, tp)
+              val vs = accu(VarianceMap.empty[TypeParamRef], unapplyArgType)
+              pt.paramRefs.map: p =>
+                vs.computedVariance(p).uncheckedNN match
+                  case -1 => p.paramInfo.lo
+                  case 1  => p.paramInfo.hi
+                  case _  => WildcardType(p.paramInfo)
+          pt.instantiate(targs).asInstanceOf[MethodType]
+        else
           val locked = ctx.typerState.ownedVars
           val tvars = constrained(pt)
           val mt = pt.instantiate(tvars).asInstanceOf[MethodType]
-          scrutineeTp <:< mt.paramInfos(0)
+          val unapplyArgType = mt.paramInfos.head
+          scrutineeTp <:< unapplyArgType
           // force type inference to infer a narrower type: could be singleton
           // see tests/patmat/i4227.scala
-          mt.paramInfos(0) <:< scrutineeTp
-          maximizeType(mt.paramInfos(0), Spans.NoSpan)
+          unapplyArgType <:< scrutineeTp
+          maximizeType(unapplyArgType, Spans.NoSpan)
           if !(ctx.typerState.ownedVars -- locked).isEmpty then
             // constraining can create type vars out of wildcard types
             // (in legalBound, by using a LevelAvoidMap)
@@ -543,7 +565,7 @@ object SpaceEngine {
             // but I'd rather have an unassigned new-new type var, than an infinite loop.
             // After all, there's nothing strictly "wrong" with unassigned type vars,
             // it just fails TreeChecker's linting.
-            maximizeType(mt.paramInfos(0), Spans.NoSpan)
+            maximizeType(unapplyArgType, Spans.NoSpan)
           mt
     }
 

From f478d7e2c7260997a7ea3df6fbaf01a06e4052a6 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Thu, 17 Oct 2024 16:25:29 +0100
Subject: [PATCH 041/306] Drop inaccessible subclasses from refineUsingParent

---
 .../src/dotty/tools/dotc/core/Decorators.scala     |  2 +-
 compiler/src/dotty/tools/dotc/core/TypeOps.scala   |  6 +++++-
 tests/pos/i21790.scala                             | 14 ++++++++++++++
 3 files changed, 20 insertions(+), 2 deletions(-)
 create mode 100644 tests/pos/i21790.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Decorators.scala b/compiler/src/dotty/tools/dotc/core/Decorators.scala
index 29d4b3fa4052..96a2d45db80d 100644
--- a/compiler/src/dotty/tools/dotc/core/Decorators.scala
+++ b/compiler/src/dotty/tools/dotc/core/Decorators.scala
@@ -292,7 +292,7 @@ object Decorators {
       case _ => String.valueOf(x).nn
 
     /** Returns the simple class name of `x`. */
-    def className: String = x.getClass.getSimpleName.nn
+    def className: String = if x == null then "<null>" else x.getClass.getSimpleName.nn
 
   extension [T](x: T)
     def assertingErrorsReported(using Context): T = {
diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
index bfda613d0586..846e4091c617 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -921,7 +921,11 @@ object TypeOps:
       for tp <- mixins.reverseIterator do
         protoTp1 <:< tp
       maximizeType(protoTp1, NoSpan)
-      wildApprox(protoTp1)
+      val inst = wildApprox(protoTp1)
+      if !inst.classSymbol.exists then
+        // E.g. i21790, can't instantiate S#CA as a subtype of O.A, because O.CA isn't accessible
+        NoType
+      else inst
     }
 
     if (protoTp1 <:< tp2) instantiate()
diff --git a/tests/pos/i21790.scala b/tests/pos/i21790.scala
new file mode 100644
index 000000000000..0cc7db935ac7
--- /dev/null
+++ b/tests/pos/i21790.scala
@@ -0,0 +1,14 @@
+package p
+
+trait S:
+  sealed trait A
+  private class CA() extends A
+
+object O extends S
+
+trait T
+
+class Test:
+  def f(e: T) = e match
+    case _: O.A =>
+    case _      =>

From 6d9ee4dcc21a1f6bd644883c099d57f6c7fbbeab Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Thu, 17 Oct 2024 19:29:59 +0200
Subject: [PATCH 042/306] Fix CI workflows for publishing releases.  (#21789)

Reuse SDKs generated in `build-sdk-package` job.
Store .sha256 for each of the files, instead of creating sha256.txt with
shas for the reach directory to ease validation
---
 .github/workflows/ci.yaml | 280 ++++++++++++++++++++++++++------------
 1 file changed, 194 insertions(+), 86 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 95a6ed24df13..5baa8d3dea81 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -729,7 +729,7 @@ jobs:
         - ${{ github.workspace }}/../../cache/sbt:/root/.sbt
         - ${{ github.workspace }}/../../cache/ivy:/root/.ivy2/cache
         - ${{ github.workspace }}/../../cache/general:/root/.cache
-    needs: [test_non_bootstrapped, test, mima, community_build_a, community_build_b, community_build_c, test_sbt, test_java8]
+    needs: [test_non_bootstrapped, test, mima, community_build_a, community_build_b, community_build_c, test_sbt, test_java8, build-sdk-package]
     if: "github.event_name == 'push'
          && startsWith(github.event.ref, 'refs/tags/')"
 
@@ -765,31 +765,51 @@ jobs:
       # Extract the release tag
       - name: Extract the release tag
         run : echo "RELEASE_TAG=${GITHUB_REF#*refs/tags/}" >> $GITHUB_ENV
-      # BUILD THE SDKs
-      - name: Build and pack the SDK (universal)
-        run : |
-          ./project/scripts/sbt dist/packArchive
-          sha256sum dist/target/scala3-* > dist/target/sha256sum.txt
-      - name: Build and pack the SDK (linux x86-64)
-        run : |
-          ./project/scripts/sbt dist-linux-x86_64/packArchive
-          sha256sum dist/linux-x86_64/target/scala3-* > dist/linux-x86_64/target/sha256sum.txt
-      - name: Build and pack the SDK (linux aarch64)
-        run : |
-          ./project/scripts/sbt dist-linux-aarch64/packArchive
-          sha256sum dist/linux-aarch64/target/scala3-* > dist/linux-aarch64/target/sha256sum.txt
-      - name: Build and pack the SDK (mac x86-64)
-        run : |
-          ./project/scripts/sbt dist-mac-x86_64/packArchive
-          sha256sum dist/mac-x86_64/target/scala3-* > dist/mac-x86_64/target/sha256sum.txt
-      - name: Build and pack the SDK (mac aarch64)
-        run : |
-          ./project/scripts/sbt dist-mac-aarch64/packArchive
-          sha256sum dist/mac-aarch64/target/scala3-* > dist/mac-aarch64/target/sha256sum.txt
-      - name: Build and pack the SDK (win x86-64)
+
+      - name: Prepare the SDKs
         run : |
-          ./project/scripts/sbt dist-win-x86_64/packArchive
-          sha256sum dist/win-x86_64/target/scala3-* > dist/win-x86_64/target/sha256sum.txt
+          function prepareSDK() {
+            distroSuffix="$1"
+            artifactId="$2"
+            artifactName="scala3-${{ env.RELEASE_TAG }}${distroSuffix}"
+
+            downloadedArchive="./artifact.zip"
+            if [[ -f "${downloadedArchive}" ]]; then
+              rm "${downloadedArchive}"
+            fi
+
+            # Download previously prepared SDK bundle
+            curl -L \
+              -H "Authorization: token ${{secrets.GITHUB_TOKEN}}" \
+              -H "Accept: application/vnd.github+json" \
+              -o "${downloadedArchive}" \
+              --retry 5 --retry-delay 10 --retry-connrefused \
+              --max-time 600 --connect-timeout 60  \
+              https://api.github.com/repos/scala/scala3/actions/artifacts/${artifactId}/zip
+
+            # Repackage content of .zip to .tar.gz and prepare digest
+            tmpDir="./archive-tmp-dir"
+            if [[ -d "${tmpDir}" ]]; then
+              rm -r "${tmpDir}"
+            fi
+            mkdir "${tmpDir}"
+            unzip "${downloadedArchive}" -d "${tmpDir}"
+
+            mv "${downloadedArchive}" "./${artifactName}.zip"
+            tar -czf "${artifactName}.tar.gz" -C "${tmpDir}" .
+
+            # Caluclate SHA for each of archive files
+            for file in "${artifactName}.zip" "${artifactName}.tar.gz"; do
+              sha256sum "${file}" > "${file}.sha256"
+            done
+          }
+          prepareSDK "" ${{needs.build-sdk-package.outputs.universal-id}}
+          prepareSDK "-aarch64-pc-linux"     ${{needs.build-sdk-package.outputs.linux-aarch64-id}}
+          prepareSDK "-x86_64-pc-linux"      ${{needs.build-sdk-package.outputs.linux-x86_64-id}}
+          prepareSDK "-aarch64-apple-darwin" ${{needs.build-sdk-package.outputs.mac-aarch64-id}}
+          prepareSDK "-x86_64-apple-darwin"  ${{needs.build-sdk-package.outputs.mac-x86_64-id}}
+          prepareSDK "-x86_64-pc-win32"      ${{needs.build-sdk-package.outputs.win-x86_64-id}}
+
       # Create the GitHub release
       - name: Create GitHub Release
         id: create_gh_release
@@ -803,179 +823,267 @@ jobs:
           draft: true
           prerelease: ${{ contains(env.RELEASE_TAG, '-') }}
 
-      - name: Upload zip archive to GitHub Release (universal)
+      # The following steps are generated using template:
+      # def template(distribution: String, suffix: String) =
+      #   def upload(kind: String, path: String, contentType: String) =
+      #     s"""- name: Upload $kind to GitHub Release ($distribution)
+      #         uses: actions/upload-release-asset@v1
+      #         env:
+      #           GITHUB_TOKEN: $${{ secrets.GITHUB_TOKEN }}
+      #         with:
+      #           upload_url: $${{ steps.create_gh_release.outputs.upload_url }}
+      #           asset_path: ./${path}
+      #           asset_name: ${path}
+      #           asset_content_type: ${contentType}"""
+      #   val filename = s"scala3-$${{ env.RELEASE_TAG }}${suffix}"
+      #   s"""
+      #       # $distribution
+      #       ${upload("zip archive", s"$filename.zip", "application/zip")}
+      #       ${upload("zip archive SHA", s"$filename.zip.sha256", "text/plain")}
+      #       ${upload("tar.gz archive", s"$filename.tar.gz", "application/gzip")}
+      #       ${upload("tar.gz archive SHA", s"$filename.tar.gz.sha256", "text/plain")}
+      # """
+
+      # @main def gen =
+      #   Seq(
+      #     template("Universal", ""),
+      #     template("Linux x86-64", "-x86_64-pc-linux"),
+      #     template("Linux aarch64", "-aarch64-pc-linux"),
+      #     template("Mac x86-64", "-x86_64-apple-darwin"),
+      #     template("Mac aarch64", "-aarcb64-apple-darwin"),
+      #     template("Windows x86_64", "-x86_64-pc-win32")
+      #   ).foreach(println)
+      # Universal
+      - name: Upload zip archive to GitHub Release (Universal)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/target/scala3-${{ env.RELEASE_TAG }}.zip
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}.zip
           asset_name: scala3-${{ env.RELEASE_TAG }}.zip
           asset_content_type: application/zip
-      - name: Upload tar.gz archive to GitHub Release (universal)
+      - name: Upload zip archive SHA to GitHub Release (Universal)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/target/scala3-${{ env.RELEASE_TAG }}.tar.gz
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}.zip.sha256
+          asset_name: scala3-${{ env.RELEASE_TAG }}.zip.sha256
+          asset_content_type: text/plain
+      - name: Upload tar.gz archive to GitHub Release (Universal)
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}.tar.gz
           asset_name: scala3-${{ env.RELEASE_TAG }}.tar.gz
           asset_content_type: application/gzip
+      - name: Upload tar.gz archive SHA to GitHub Release (Universal)
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}.tar.gz.sha256
+          asset_name: scala3-${{ env.RELEASE_TAG }}.tar.gz.sha256
+          asset_content_type: text/plain
+
 
-      - name: Upload zip archive to GitHub Release (linux x86-64)
+      # Linux x86-64
+      - name: Upload zip archive to GitHub Release (Linux x86-64)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/linux-x86_64/target/scala3-${{ env.RELEASE_TAG }}-x86_64-pc-linux.zip
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-x86_64-pc-linux.zip
           asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-pc-linux.zip
           asset_content_type: application/zip
-      - name: Upload tar.gz archive to GitHub Release (linux x86-64)
+      - name: Upload zip archive SHA to GitHub Release (Linux x86-64)
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-x86_64-pc-linux.zip.sha256
+          asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-pc-linux.zip.sha256
+          asset_content_type: text/plain
+      - name: Upload tar.gz archive to GitHub Release (Linux x86-64)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/linux-x86_64/target/scala3-${{ env.RELEASE_TAG }}-x86_64-pc-linux.tar.gz
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-x86_64-pc-linux.tar.gz
           asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-pc-linux.tar.gz
           asset_content_type: application/gzip
+      - name: Upload tar.gz archive SHA to GitHub Release (Linux x86-64)
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-x86_64-pc-linux.tar.gz.sha256
+          asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-pc-linux.tar.gz.sha256
+          asset_content_type: text/plain
+
 
-      - name: Upload zip archive to GitHub Release (linux aarch64)
+      # Linux aarch64
+      - name: Upload zip archive to GitHub Release (Linux aarch64)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/linux-aarch64/target/scala3-${{ env.RELEASE_TAG }}-aarch64-pc-linux.zip
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-aarch64-pc-linux.zip
           asset_name: scala3-${{ env.RELEASE_TAG }}-aarch64-pc-linux.zip
           asset_content_type: application/zip
-      - name: Upload tar.gz archive to GitHub Release (linux aarch64)
+      - name: Upload zip archive SHA to GitHub Release (Linux aarch64)
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-aarch64-pc-linux.zip.sha256
+          asset_name: scala3-${{ env.RELEASE_TAG }}-aarch64-pc-linux.zip.sha256
+          asset_content_type: text/plain
+      - name: Upload tar.gz archive to GitHub Release (Linux aarch64)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/linux-aarch64/target/scala3-${{ env.RELEASE_TAG }}-aarch64-pc-linux.tar.gz
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-aarch64-pc-linux.tar.gz
           asset_name: scala3-${{ env.RELEASE_TAG }}-aarch64-pc-linux.tar.gz
           asset_content_type: application/gzip
+      - name: Upload tar.gz archive SHA to GitHub Release (Linux aarch64)
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-aarch64-pc-linux.tar.gz.sha256
+          asset_name: scala3-${{ env.RELEASE_TAG }}-aarch64-pc-linux.tar.gz.sha256
+          asset_content_type: text/plain
 
-      - name: Upload zip archive to GitHub Release (mac x86-64)
+
+      # Mac x86-64
+      - name: Upload zip archive to GitHub Release (Mac x86-64)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/mac-x86_64/target/scala3-${{ env.RELEASE_TAG }}-x86_64-apple-darwin.zip
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-x86_64-apple-darwin.zip
           asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-apple-darwin.zip
           asset_content_type: application/zip
-      - name: Upload tar.gz archive to GitHub Release (mac x86-64)
+      - name: Upload zip archive SHA to GitHub Release (Mac x86-64)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/mac-x86_64/target/scala3-${{ env.RELEASE_TAG }}-x86_64-apple-darwin.tar.gz
-          asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-apple-darwin.tar.gz
-          asset_content_type: application/gzip
-
-      - name: Upload zip archive to GitHub Release (mac aarch64)
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-x86_64-apple-darwin.zip.sha256
+          asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-apple-darwin.zip.sha256
+          asset_content_type: text/plain
+      - name: Upload tar.gz archive to GitHub Release (Mac x86-64)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/mac-aarch64/target/scala3-${{ env.RELEASE_TAG }}-aarch64-apple-darwin.zip
-          asset_name: scala3-${{ env.RELEASE_TAG }}-aarch64-apple-darwin.zip
-          asset_content_type: application/zip
-      - name: Upload tar.gz archive to GitHub Release (mac aarch64)
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-x86_64-apple-darwin.tar.gz
+          asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-apple-darwin.tar.gz
+          asset_content_type: application/gzip
+      - name: Upload tar.gz archive SHA to GitHub Release (Mac x86-64)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/mac-aarch64/target/scala3-${{ env.RELEASE_TAG }}-aarch64-apple-darwin.tar.gz
-          asset_name: scala3-${{ env.RELEASE_TAG }}-aarch64-apple-darwin.tar.gz
-          asset_content_type: application/gzip
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-x86_64-apple-darwin.tar.gz.sha256
+          asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-apple-darwin.tar.gz.sha256
+          asset_content_type: text/plain
+
 
-      - name: Upload zip archive to GitHub Release (win x86-64)
+      # Mac aarch64
+      - name: Upload zip archive to GitHub Release (Mac aarch64)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/win-x86_64/target/scala3-${{ env.RELEASE_TAG }}-x86_64-pc-win32.zip
-          asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-pc-win32.zip
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-aarcb64-apple-darwin.zip
+          asset_name: scala3-${{ env.RELEASE_TAG }}-aarcb64-apple-darwin.zip
           asset_content_type: application/zip
-      - name: Upload tar.gz archive to GitHub Release (win x86-64)
+      - name: Upload zip archive SHA to GitHub Release (Mac aarch64)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/win-x86_64/target/scala3-${{ env.RELEASE_TAG }}-x86_64-pc-win32.tar.gz
-          asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-pc-win32.tar.gz
-          asset_content_type: application/gzip
-
-
-      - name: Upload SHA256 sum of the release artefacts to GitHub Release (universal)
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-aarcb64-apple-darwin.zip.sha256
+          asset_name: scala3-${{ env.RELEASE_TAG }}-aarcb64-apple-darwin.zip.sha256
+          asset_content_type: text/plain
+      - name: Upload tar.gz archive to GitHub Release (Mac aarch64)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/target/sha256sum.txt
-          asset_name: sha256sum.txt
-          asset_content_type: text/plain
-
-      - name: Upload SHA256 sum of the release artefacts to GitHub Release (linux x86-64)
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-aarcb64-apple-darwin.tar.gz
+          asset_name: scala3-${{ env.RELEASE_TAG }}-aarcb64-apple-darwin.tar.gz
+          asset_content_type: application/gzip
+      - name: Upload tar.gz archive SHA to GitHub Release (Mac aarch64)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/linux-x86_64/target/sha256sum.txt
-          asset_name: sha256sum-x86_64-pc-linux.txt
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-aarcb64-apple-darwin.tar.gz.sha256
+          asset_name: scala3-${{ env.RELEASE_TAG }}-aarcb64-apple-darwin.tar.gz.sha256
           asset_content_type: text/plain
 
-      - name: Upload SHA256 sum of the release artefacts to GitHub Release (linux aarch64)
+
+      # Windows x86_64
+      - name: Upload zip archive to GitHub Release (Windows x86_64)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/linux-aarch64/target/sha256sum.txt
-          asset_name: sha256sum-aarch64-pc-linux.txt
-          asset_content_type: text/plain
-
-      - name: Upload SHA256 sum of the release artefacts to GitHub Release (mac x86-64)
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-x86_64-pc-win32.zip
+          asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-pc-win32.zip
+          asset_content_type: application/zip
+      - name: Upload zip archive SHA to GitHub Release (Windows x86_64)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/mac-x86_64/target/sha256sum.txt
-          asset_name: sha256sum-x86_64-apple-darwin.txt
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-x86_64-pc-win32.zip.sha256
+          asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-pc-win32.zip.sha256
           asset_content_type: text/plain
-
-      - name: Upload SHA256 sum of the release artefacts to GitHub Release (mac aarch64)
+      - name: Upload tar.gz archive to GitHub Release (Windows x86_64)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/mac-aarch64/target/sha256sum.txt
-          asset_name: sha256sum-aarch64-apple-darwin.txt
-          asset_content_type: text/plain
-
-      - name: Upload SHA256 sum of the release artefacts to GitHub Release (win x86-64)
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-x86_64-pc-win32.tar.gz
+          asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-pc-win32.tar.gz
+          asset_content_type: application/gzip
+      - name: Upload tar.gz archive SHA to GitHub Release (Windows x86_64)
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./dist/win-x86_64/target/sha256sum.txt
-          asset_name: sha256sum-x86_64-pc-win32.txt
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-x86_64-pc-win32.tar.gz.sha256
+          asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-pc-win32.tar.gz.sha256
           asset_content_type: text/plain
 
       - name: Publish Release

From a0db7c1ebf476cfdd1c0396b0ba1bd622e2d36b4 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Thu, 26 Sep 2024 21:06:14 +0200
Subject: [PATCH 043/306] Allow opaque type def in repl

---
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 5a3be6505715..4172914c0fb0 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -4696,6 +4696,8 @@ object Parsers {
           stats += closure(in.offset, Location.InBlock, modifiers(BitSet(IMPLICIT)))
         else if isIdent(nme.extension) && followingIsExtension() then
           stats += extension()
+        else if ctx.mode.is(Mode.Interactive) && isDefIntro(localModifierTokens) then
+          stats +++= localDef(in.offset)
         else if isDefIntro(localModifierTokens, excludedSoftModifiers = Set(nme.`opaque`)) then
           stats +++= localDef(in.offset)
         else

From 16ebbea25de6074ead7388c09434758c424700a6 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Fri, 4 Oct 2024 03:42:03 +0200
Subject: [PATCH 044/306] Only allow opaque type def at outermost

---
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala | 4 ++--
 compiler/src/dotty/tools/repl/ParseResult.scala     | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 4172914c0fb0..6d35aeb9ac82 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -4684,7 +4684,7 @@ object Parsers {
      *                 | Expr1
      *                 |
      */
-    def blockStatSeq(): List[Tree] = checkNoEscapingPlaceholders {
+    def blockStatSeq(outermost: Boolean = false): List[Tree] = checkNoEscapingPlaceholders {
       val stats = new ListBuffer[Tree]
       while
         var empty = false
@@ -4696,7 +4696,7 @@ object Parsers {
           stats += closure(in.offset, Location.InBlock, modifiers(BitSet(IMPLICIT)))
         else if isIdent(nme.extension) && followingIsExtension() then
           stats += extension()
-        else if ctx.mode.is(Mode.Interactive) && isDefIntro(localModifierTokens) then
+        else if outermost && ctx.mode.is(Mode.Interactive) && isDefIntro(localModifierTokens) then
           stats +++= localDef(in.offset)
         else if isDefIntro(localModifierTokens, excludedSoftModifiers = Set(nme.`opaque`)) then
           stats +++= localDef(in.offset)
diff --git a/compiler/src/dotty/tools/repl/ParseResult.scala b/compiler/src/dotty/tools/repl/ParseResult.scala
index b9139343bca1..24a624173050 100644
--- a/compiler/src/dotty/tools/repl/ParseResult.scala
+++ b/compiler/src/dotty/tools/repl/ParseResult.scala
@@ -122,7 +122,7 @@ object ParseResult {
 
   private def parseStats(using Context): List[untpd.Tree] = {
     val parser = new Parser(ctx.source)
-    val stats = parser.blockStatSeq()
+    val stats = parser.blockStatSeq(outermost = true)
     parser.accept(Tokens.EOF)
     stats
   }

From 634d9b79beae0e4098ef93affd25a5d761268e14 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Fri, 11 Oct 2024 05:50:21 +0200
Subject: [PATCH 045/306] Add REPL test

---
 .../dotty/tools/repl/ReplCompilerTests.scala  | 28 ++++++++++++++++++-
 1 file changed, 27 insertions(+), 1 deletion(-)

diff --git a/compiler/test/dotty/tools/repl/ReplCompilerTests.scala b/compiler/test/dotty/tools/repl/ReplCompilerTests.scala
index 374f53dbd011..221eb8acb9de 100644
--- a/compiler/test/dotty/tools/repl/ReplCompilerTests.scala
+++ b/compiler/test/dotty/tools/repl/ReplCompilerTests.scala
@@ -462,10 +462,36 @@ class ReplCompilerTests extends ReplTest:
     .andThen:
       run("0") // check for crash
       val last = lines()
-      println(last)
       assertTrue(last(0), last(0) == ("Options incompatible with repl will be ignored: -Ybest-effort, -Ywith-best-effort-tasty"))
       assertTrue(last(1), last(1) == ("val res0: Int = 0"))
 
+  @Test def `i9879`: Unit = initially:
+    run {
+      """|opaque type A = Int; def getA: A = 0
+         |object Wrapper { opaque type A = Int; def getA: A = 1 }
+         |val x = getA
+         |val y = Wrapper.getA""".stripMargin
+    }
+    val expected = List(
+      "def getA: A",
+      "// defined object Wrapper",
+      "val x: A = 0",
+      "val y: Wrapper.A = 1"
+    )
+    assertEquals(expected, lines())
+
+  @Test def `i9879b`: Unit = initially:
+    run {
+      """|def test =
+         |  type A = Int
+         |  opaque type B = String
+         |  object Wrapper { opaque type C = Int }
+         |  ()""".stripMargin
+    }
+    val all = lines()
+    assertEquals(6, all.length)
+    assertTrue(all.head.startsWith("-- [E103] Syntax Error"))
+    assertTrue(all.exists(_.trim().startsWith("|  Illegal start of statement: this modifier is not allowed here")))
 
 object ReplCompilerTests:
 

From 3a98a1cd3efd52fdb7e92f03d7d9ddc7f8ed3282 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Fri, 18 Oct 2024 10:44:58 +0200
Subject: [PATCH 046/306] Remove extra if

---
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 6d35aeb9ac82..6390d8d32d3f 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -4696,9 +4696,11 @@ object Parsers {
           stats += closure(in.offset, Location.InBlock, modifiers(BitSet(IMPLICIT)))
         else if isIdent(nme.extension) && followingIsExtension() then
           stats += extension()
-        else if outermost && ctx.mode.is(Mode.Interactive) && isDefIntro(localModifierTokens) then
-          stats +++= localDef(in.offset)
-        else if isDefIntro(localModifierTokens, excludedSoftModifiers = Set(nme.`opaque`)) then
+        else if isDefIntro(localModifierTokens,
+            excludedSoftModifiers =
+              // Allow opaque definitions at outermost level in REPL.
+              if outermost && ctx.mode.is(Mode.Interactive)
+              then Set.empty else Set(nme.`opaque`)) then
           stats +++= localDef(in.offset)
         else
           empty = true

From dd47185afa1a2ef0e0fa6f99ed7c40d0e87b49ee Mon Sep 17 00:00:00 2001
From: Hamza Remmal <hamza@remmal.dev>
Date: Fri, 18 Oct 2024 12:22:18 +0200
Subject: [PATCH 047/306] Add zip and unzip to the CI

---
 .github/Dockerfile        |  3 ++-
 .github/workflows/ci.yaml | 26 +++++++++++++-------------
 2 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/.github/Dockerfile b/.github/Dockerfile
index d56ec6a59f2d..59d46fd169d9 100644
--- a/.github/Dockerfile
+++ b/.github/Dockerfile
@@ -15,7 +15,8 @@ RUN apt-get update && \
                        openjdk-17-jdk-headless \
                        openjdk-21-jdk-headless && \
     (curl -fsSL https://deb.nodesource.com/setup_18.x | bash -) && \
-    apt-get install -y nodejs
+    apt-get install -y nodejs && \
+    apt-get install -y zip unzip
 
 
 # Install sbt
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 95a6ed24df13..8d91e22c8ee8 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -48,7 +48,7 @@ jobs:
   test_non_bootstrapped:
     runs-on: [self-hosted, Linux]
     container:
-      image: lampepfl/dotty:2023-11-07
+      image: lampepfl/dotty:2024-10-18
       options: --cpu-shares 4096
       volumes:
         - ${{ github.workspace }}/../../cache/sbt:/root/.sbt
@@ -100,7 +100,7 @@ jobs:
   test:
     runs-on: [self-hosted, Linux]
     container:
-      image: lampepfl/dotty:2023-11-07
+      image: lampepfl/dotty:2024-10-18
       options: --cpu-shares 4096
       volumes:
         - ${{ github.workspace }}/../../cache/sbt:/root/.sbt
@@ -160,7 +160,7 @@ jobs:
   test_scala2_library_tasty:
     runs-on: [self-hosted, Linux]
     container:
-      image: lampepfl/dotty:2023-11-07
+      image: lampepfl/dotty:2024-10-18
       options: --cpu-shares 4096
       volumes:
         - ${{ github.workspace }}/../../cache/sbt:/root/.sbt
@@ -287,7 +287,7 @@ jobs:
     name: MiMa
     runs-on: [self-hosted, Linux]
     container:
-      image: lampepfl/dotty:2023-11-07
+      image: lampepfl/dotty:2024-10-18
       options: --cpu-shares 4096
       volumes:
         - ${{ github.workspace }}/../../cache/sbt:/root/.sbt
@@ -338,7 +338,7 @@ jobs:
   community_build_a:
     runs-on: [self-hosted, Linux]
     container:
-      image: lampepfl/dotty:2023-11-07
+      image: lampepfl/dotty:2024-10-18
       options: --cpu-shares 4096
       volumes:
         - ${{ github.workspace }}/../../cache/sbt:/root/.sbt
@@ -395,7 +395,7 @@ jobs:
   community_build_b:
     runs-on: [self-hosted, Linux]
     container:
-      image: lampepfl/dotty:2023-11-07
+      image: lampepfl/dotty:2024-10-18
       options: --cpu-shares 4096
       volumes:
         - ${{ github.workspace }}/../../cache/sbt:/root/.sbt
@@ -452,7 +452,7 @@ jobs:
   community_build_c:
     runs-on: [self-hosted, Linux]
     container:
-      image: lampepfl/dotty:2023-11-07
+      image: lampepfl/dotty:2024-10-18
       options: --cpu-shares 4096
       volumes:
         - ${{ github.workspace }}/../../cache/sbt:/root/.sbt
@@ -509,7 +509,7 @@ jobs:
   test_sbt:
     runs-on: [self-hosted, Linux]
     container:
-      image: lampepfl/dotty:2023-11-07
+      image: lampepfl/dotty:2024-10-18
       options: --cpu-shares 4096
       volumes:
         - ${{ github.workspace }}/../../cache/sbt:/root/.sbt
@@ -554,7 +554,7 @@ jobs:
   test_java8:
     runs-on: [self-hosted, Linux]
     container:
-      image: lampepfl/dotty:2023-11-07
+      image: lampepfl/dotty:2024-10-18
       options: --cpu-shares 4096
       volumes:
         - ${{ github.workspace }}/../../cache/sbt:/root/.sbt
@@ -614,7 +614,7 @@ jobs:
   publish_nightly:
     runs-on: [self-hosted, Linux]
     container:
-      image: lampepfl/dotty:2023-11-07
+      image: lampepfl/dotty:2024-10-18
       options: --cpu-shares 4096
       volumes:
         - ${{ github.workspace }}/../../cache/sbt:/root/.sbt
@@ -677,7 +677,7 @@ jobs:
   nightly_documentation:
     runs-on: [self-hosted, Linux]
     container:
-      image: lampepfl/dotty:2023-11-07
+      image: lampepfl/dotty:2024-10-18
       options: --cpu-shares 4096
       volumes:
         - ${{ github.workspace }}/../../cache/sbt:/root/.sbt
@@ -723,7 +723,7 @@ jobs:
       contents: write  # for actions/create-release to create a release
     runs-on: [self-hosted, Linux]
     container:
-      image: lampepfl/dotty:2023-11-07
+      image: lampepfl/dotty:2024-10-18
       options: --cpu-shares 4096
       volumes:
         - ${{ github.workspace }}/../../cache/sbt:/root/.sbt
@@ -985,7 +985,7 @@ jobs:
   open_issue_on_failure:
     runs-on: [self-hosted, Linux]
     container:
-      image: lampepfl/dotty:2023-11-07
+      image: lampepfl/dotty:2024-10-18
     needs: [nightly_documentation, test_windows_full]
     # The `failure()` expression is true iff at least one of the dependencies
     # of this job (including transitive dependencies) has failed.

From 3161e06b3509d93d39ae05f52f95ea407e53fb84 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Fri, 18 Oct 2024 13:14:05 +0200
Subject: [PATCH 048/306] Add batter-fors doc link to sidebar

---
 docs/sidebar.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/sidebar.yml b/docs/sidebar.yml
index f12e732f1c6f..74aee3dfc668 100644
--- a/docs/sidebar.yml
+++ b/docs/sidebar.yml
@@ -162,6 +162,7 @@ subsection:
           - page: reference/experimental/modularity.md
           - page: reference/experimental/typeclasses.md
           - page: reference/experimental/runtimeChecked.md
+          - page: reference/experimental/better-fors.md
       - page: reference/syntax.md
       - title: Language Versions
         index: reference/language-versions/language-versions.md

From 6d040c517682856fad4b4969e08c4eb405da551e Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Fri, 18 Oct 2024 17:47:33 +0200
Subject: [PATCH 049/306] fix: Drop copied parent refinements before generating
 bytecode (#21733)

Refinements are copied over from parents, because they might be needed
for tracked members that should have more specific types in the child.
These members are generated without an implementation and should not be
used in runtime.

possible fix for #21213

---------

Co-authored-by: Dale Wijnand <dale.wijnand@gmail.com>
Co-authored-by: Matt Bovel <matthieu@bovel.net>
---
 compiler/src/dotty/tools/dotc/Compiler.scala  |  1 +
 .../transform/DropParentRefinements.scala     | 35 +++++++++++++++++++
 .../dotty/tools/dotc/transform/Getters.scala  |  2 +-
 .../src/dotty/tools/dotc/typer/Namer.scala    |  8 ++---
 .../src/dotty/tools/dotc/typer/Typer.scala    |  5 ++-
 .../transformed/lazy-vals-legacy.check        |  2 +-
 .../printing/transformed/lazy-vals-new.check  |  2 +-
 tests/run/i21213-min.check                    |  1 +
 tests/run/i21213-min.scala                    |  9 +++++
 tests/run/i21213.check                        |  1 +
 tests/run/i21213.scala                        | 10 ++++++
 11 files changed, 68 insertions(+), 8 deletions(-)
 create mode 100644 compiler/src/dotty/tools/dotc/transform/DropParentRefinements.scala
 create mode 100644 tests/run/i21213-min.check
 create mode 100644 tests/run/i21213-min.scala
 create mode 100644 tests/run/i21213.check
 create mode 100644 tests/run/i21213.scala

diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala
index 9b130e7d7804..f9503e4f8554 100644
--- a/compiler/src/dotty/tools/dotc/Compiler.scala
+++ b/compiler/src/dotty/tools/dotc/Compiler.scala
@@ -132,6 +132,7 @@ class Compiler {
          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 DropParentRefinements,  // Drop parent refinements from a template
          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
diff --git a/compiler/src/dotty/tools/dotc/transform/DropParentRefinements.scala b/compiler/src/dotty/tools/dotc/transform/DropParentRefinements.scala
new file mode 100644
index 000000000000..1960568dc505
--- /dev/null
+++ b/compiler/src/dotty/tools/dotc/transform/DropParentRefinements.scala
@@ -0,0 +1,35 @@
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.transform.MegaPhase.MiniPhase
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer
+import dotty.tools.dotc.typer.Typer
+
+object DropParentRefinements:
+  val name: String = "dropParentRefinements"
+  val description: String = "drop parent refinements from a template"
+
+/** Drop parent refinements from a template, as they are generated without
+  * an implementation. These refinements are unusally required for tracked
+  * members with more specific types.
+  */
+class DropParentRefinements extends MiniPhase with IdentityDenotTransformer:
+  thisPhase =>
+  import tpd.*
+
+  override def phaseName: String = DropParentRefinements.name
+
+  override def description: String = DropParentRefinements.description
+
+  override def runsAfterGroupsOf: Set[String] = Set(CountOuterAccesses.name)
+
+  override def changesMembers: Boolean = true // the phase drops parent refinements
+
+  override def transformTemplate(tree: tpd.Template)(using Context): tpd.Tree =
+    val newBody = tree.body.filter(!_.hasAttachment(Typer.RefinementFromParent))
+    tree.body.foreach { member =>
+      if member.hasAttachment(Typer.RefinementFromParent) then
+        member.symbol.dropAfter(thisPhase)
+    }
+    cpy.Template(tree)(body = newBody)
diff --git a/compiler/src/dotty/tools/dotc/transform/Getters.scala b/compiler/src/dotty/tools/dotc/transform/Getters.scala
index 43289209d146..a58dffa04223 100644
--- a/compiler/src/dotty/tools/dotc/transform/Getters.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Getters.scala
@@ -103,7 +103,7 @@ class Getters extends MiniPhase with SymTransformer { 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)
+    val getterDef = DefDef(sym.asTerm, tree.rhs).withSpan(tree.span).withAttachmentsFrom(tree)
     if !sym.is(Mutable) then return getterDef
     ensureSetter(sym.asTerm)
     if !newSetters.contains(sym.setter) then return getterDef
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 6167db62fbe0..0849e57b8c7d 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -877,16 +877,16 @@ class Namer { typer: Typer =>
     protected def addAnnotations(sym: Symbol): Unit = original match {
       case original: untpd.MemberDef =>
         lazy val annotCtx = annotContext(original, sym)
-        original.setMods: 
+        original.setMods:
           original.mods.withAnnotations :
-            original.mods.annotations.mapConserve: annotTree =>  
+            original.mods.annotations.mapConserve: annotTree =>
               val cls = typedAheadAnnotationClass(annotTree)(using annotCtx)
               if (cls eq sym)
                 report.error(em"An annotation class cannot be annotated with iself", annotTree.srcPos)
                 annotTree
               else
-                val ann = 
-                  if cls.is(JavaDefined) then Checking.checkNamedArgumentForJavaAnnotation(annotTree, cls.asClass) 
+                val ann =
+                  if cls.is(JavaDefined) then Checking.checkNamedArgumentForJavaAnnotation(annotTree, cls.asClass)
                   else annotTree
                 val ann1 = Annotation.deferred(cls)(typedAheadExpr(ann)(using annotCtx))
                 sym.addAnnotation(ann1)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index ce72aac596c0..89ce01231fed 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -78,6 +78,9 @@ object Typer {
   /** An attachment for GADT constraints that were inferred for a pattern. */
   val InferredGadtConstraints = new Property.StickyKey[core.GadtConstraint]
 
+  /** Indicates that a definition was copied over from the parent refinements */
+  val RefinementFromParent = new Property.StickyKey[Unit]
+
   /** An attachment on a Select node with an `apply` field indicating that the `apply`
    *  was inserted by the Typer.
    */
@@ -3071,7 +3074,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             ( if sym.isType then TypeDef(sym.asType)
               else if sym.is(Method) then DefDef(sym.asTerm)
               else ValDef(sym.asTerm)
-            ).withSpan(impl.span.startPos)
+            ).withSpan(impl.span.startPos).withAttachment(RefinementFromParent, ())
           body ++ refinements
         case None =>
           body
diff --git a/tests/printing/transformed/lazy-vals-legacy.check b/tests/printing/transformed/lazy-vals-legacy.check
index 2768a89b9c9e..d8969619d2b2 100644
--- a/tests/printing/transformed/lazy-vals-legacy.check
+++ b/tests/printing/transformed/lazy-vals-legacy.check
@@ -1,4 +1,4 @@
-[[syntax trees at end of MegaPhase{dropOuterAccessors, checkNoSuperThis, flatten, transformWildcards, moveStatic, expandPrivate, restoreScopes, selectStatic, Collect entry points, collectSuperCalls, repeatableAnnotations}]] // tests/printing/transformed/lazy-vals-legacy.scala
+[[syntax trees at end of MegaPhase{dropOuterAccessors, dropParentRefinements, checkNoSuperThis, flatten, transformWildcards, moveStatic, expandPrivate, restoreScopes, selectStatic, Collect entry points, collectSuperCalls, repeatableAnnotations}]] // tests/printing/transformed/lazy-vals-legacy.scala
 package <empty> {
   @SourceFile("tests/printing/transformed/lazy-vals-legacy.scala") final module
     class A extends Object {
diff --git a/tests/printing/transformed/lazy-vals-new.check b/tests/printing/transformed/lazy-vals-new.check
index 05471e5677dc..8997f0109e79 100644
--- a/tests/printing/transformed/lazy-vals-new.check
+++ b/tests/printing/transformed/lazy-vals-new.check
@@ -1,4 +1,4 @@
-[[syntax trees at end of MegaPhase{dropOuterAccessors, checkNoSuperThis, flatten, transformWildcards, moveStatic, expandPrivate, restoreScopes, selectStatic, Collect entry points, collectSuperCalls, repeatableAnnotations}]] // tests/printing/transformed/lazy-vals-new.scala
+[[syntax trees at end of MegaPhase{dropOuterAccessors, dropParentRefinements, checkNoSuperThis, flatten, transformWildcards, moveStatic, expandPrivate, restoreScopes, selectStatic, Collect entry points, collectSuperCalls, repeatableAnnotations}]] // tests/printing/transformed/lazy-vals-new.scala
 package <empty> {
   @SourceFile("tests/printing/transformed/lazy-vals-new.scala") final module
     class A extends Object {
diff --git a/tests/run/i21213-min.check b/tests/run/i21213-min.check
new file mode 100644
index 000000000000..5716ca5987cb
--- /dev/null
+++ b/tests/run/i21213-min.check
@@ -0,0 +1 @@
+bar
diff --git a/tests/run/i21213-min.scala b/tests/run/i21213-min.scala
new file mode 100644
index 000000000000..0f6aa6f8ddd5
--- /dev/null
+++ b/tests/run/i21213-min.scala
@@ -0,0 +1,9 @@
+import scala.language.experimental.modularity
+import scala.language.future
+
+sealed abstract class Foo(tracked val discriminator: String)
+class Bar extends Foo("bar")
+
+val bar: Foo = Bar()
+object Test extends App:
+  println(bar.discriminator)
diff --git a/tests/run/i21213.check b/tests/run/i21213.check
new file mode 100644
index 000000000000..5716ca5987cb
--- /dev/null
+++ b/tests/run/i21213.check
@@ -0,0 +1 @@
+bar
diff --git a/tests/run/i21213.scala b/tests/run/i21213.scala
new file mode 100644
index 000000000000..ec609afd7da3
--- /dev/null
+++ b/tests/run/i21213.scala
@@ -0,0 +1,10 @@
+import scala.language.experimental.modularity
+import scala.language.future
+
+enum Foo(tracked val discriminator: String):
+  case Bar() extends Foo("bar")
+  case Baz() extends Foo("baz")
+
+val bar: Foo = Foo.Bar()
+object Test extends App:
+  println(bar.discriminator)

From 34f1c546b968f2d14443e48e268a93c3f19923d1 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Sat, 19 Oct 2024 20:04:40 +0200
Subject: [PATCH 050/306] Fix and future-proof the CI release scripts (#21810)

- Forward-ports changes to `publish_release` CI job from `release-3.6.1`
branch.
* Fix building SDK archives, don't use `build-sdk-packages` job that
produced artifacts in SNAPSHOT version
  * Fix typos introduced in template (forward port from `release-3.6.0`)
- Detect and check version used to publish artifacts:
* For release builds ensure that `version` is always matching tag used
to trigger CI job
* For nightly builds ensure that `version` is following the expected
pattern
---
 .github/workflows/ci.yaml | 89 +++++++++++++++++++++------------------
 1 file changed, 47 insertions(+), 42 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index d64c02c55042..72f4f5559fd7 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -663,6 +663,13 @@ jobs:
           echo "This build version: $ver"
           echo "THISBUILD_VERSION=$ver" >> $GITHUB_ENV
 
+      - name: Check is version matching pattern
+        run: |
+          if ! grep -Eo "3\.[0-9]+\.[0-9]+-RC[0-9]+-bin-[0-9]{8}-[a-zA-Z0-9]{7}-NIGHTLY" <<< "${{ env.THISBUILD_VERSION }}"; then
+            echo "Version used by compiler to publish nightly release does not match expected pattern"
+            exit 1
+          fi
+
       - name: Check whether not yet published
         id: not_yet_published
         continue-on-error: true
@@ -766,49 +773,47 @@ jobs:
       - name: Extract the release tag
         run : echo "RELEASE_TAG=${GITHUB_REF#*refs/tags/}" >> $GITHUB_ENV
 
+      - name: Check compiler version
+        shell: bash
+        run : |
+          version=$(./project/scripts/sbt "print scala3-compiler-bootstrapped/version" | tail -n1)
+          echo "This build version: ${version}"
+          if [ "${version}" != "${{ env.RELEASE_TAG }}" ]; then
+            echo "Compiler version for this build '${version}', does not match tag: ${{ env.RELEASE_TAG }}"
+            exit 1
+          fi
+
       - name: Prepare the SDKs
+        shell: bash
         run : |
-          function prepareSDK() {
+          prepareSDK() {
             distroSuffix="$1"
-            artifactId="$2"
+            sbtProject="$2"
+            distDir="$3"
+
+            # Build binaries
+            ./project/scripts/sbt "${sbtProject}/Universal/stage"
+
+            outputPath="${distDir}/target/universal/stage"
             artifactName="scala3-${{ env.RELEASE_TAG }}${distroSuffix}"
+            zipArchive="${artifactName}.zip"
+            tarGzArchive="${artifactName}.tar.gz"
 
-            downloadedArchive="./artifact.zip"
-            if [[ -f "${downloadedArchive}" ]]; then
-              rm "${downloadedArchive}"
-            fi
-
-            # Download previously prepared SDK bundle
-            curl -L \
-              -H "Authorization: token ${{secrets.GITHUB_TOKEN}}" \
-              -H "Accept: application/vnd.github+json" \
-              -o "${downloadedArchive}" \
-              --retry 5 --retry-delay 10 --retry-connrefused \
-              --max-time 600 --connect-timeout 60  \
-              https://api.github.com/repos/scala/scala3/actions/artifacts/${artifactId}/zip
-
-            # Repackage content of .zip to .tar.gz and prepare digest
-            tmpDir="./archive-tmp-dir"
-            if [[ -d "${tmpDir}" ]]; then
-              rm -r "${tmpDir}"
-            fi
-            mkdir "${tmpDir}"
-            unzip "${downloadedArchive}" -d "${tmpDir}"
-
-            mv "${downloadedArchive}" "./${artifactName}.zip"
-            tar -czf "${artifactName}.tar.gz" -C "${tmpDir}" .
+            cwd=$(pwd)
+            (cd $outputPath && zip -r ${zipArchive} . && mv ${zipArchive} "${cwd}/")
+            tar -czf ${tarGzArchive} -C "$outputPath" .
 
             # Caluclate SHA for each of archive files
-            for file in "${artifactName}.zip" "${artifactName}.tar.gz"; do
+            for file in "${zipArchive}" "${tarGzArchive}"; do
               sha256sum "${file}" > "${file}.sha256"
             done
           }
-          prepareSDK "" ${{needs.build-sdk-package.outputs.universal-id}}
-          prepareSDK "-aarch64-pc-linux"     ${{needs.build-sdk-package.outputs.linux-aarch64-id}}
-          prepareSDK "-x86_64-pc-linux"      ${{needs.build-sdk-package.outputs.linux-x86_64-id}}
-          prepareSDK "-aarch64-apple-darwin" ${{needs.build-sdk-package.outputs.mac-aarch64-id}}
-          prepareSDK "-x86_64-apple-darwin"  ${{needs.build-sdk-package.outputs.mac-x86_64-id}}
-          prepareSDK "-x86_64-pc-win32"      ${{needs.build-sdk-package.outputs.win-x86_64-id}}
+          prepareSDK ""                      "dist"               "./dist/"
+          prepareSDK "-aarch64-pc-linux"     "dist-linux-aarch64" "./dist/linux-aarch64/"
+          prepareSDK "-x86_64-pc-linux"      "dist-linux-x86_64"  "./dist/linux-x86_64/"
+          prepareSDK "-aarch64-apple-darwin" "dist-mac-aarch64"   "./dist/mac-aarch64/"
+          prepareSDK "-x86_64-apple-darwin"  "dist-mac-x86_64"    "./dist/mac-x86_64/"
+          prepareSDK "-x86_64-pc-win32"      "dist-win-x86_64"    "./dist/win-x86_64/"
 
       # Create the GitHub release
       - name: Create GitHub Release
@@ -850,7 +855,7 @@ jobs:
       #     template("Linux x86-64", "-x86_64-pc-linux"),
       #     template("Linux aarch64", "-aarch64-pc-linux"),
       #     template("Mac x86-64", "-x86_64-apple-darwin"),
-      #     template("Mac aarch64", "-aarcb64-apple-darwin"),
+      #     template("Mac aarch64", "-aarch64-apple-darwin"),
       #     template("Windows x86_64", "-x86_64-pc-win32")
       #   ).foreach(println)
       # Universal
@@ -1016,8 +1021,8 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./scala3-${{ env.RELEASE_TAG }}-aarcb64-apple-darwin.zip
-          asset_name: scala3-${{ env.RELEASE_TAG }}-aarcb64-apple-darwin.zip
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-aarch64-apple-darwin.zip
+          asset_name: scala3-${{ env.RELEASE_TAG }}-aarch64-apple-darwin.zip
           asset_content_type: application/zip
       - name: Upload zip archive SHA to GitHub Release (Mac aarch64)
         uses: actions/upload-release-asset@v1
@@ -1025,8 +1030,8 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./scala3-${{ env.RELEASE_TAG }}-aarcb64-apple-darwin.zip.sha256
-          asset_name: scala3-${{ env.RELEASE_TAG }}-aarcb64-apple-darwin.zip.sha256
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-aarch64-apple-darwin.zip.sha256
+          asset_name: scala3-${{ env.RELEASE_TAG }}-aarch64-apple-darwin.zip.sha256
           asset_content_type: text/plain
       - name: Upload tar.gz archive to GitHub Release (Mac aarch64)
         uses: actions/upload-release-asset@v1
@@ -1034,8 +1039,8 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./scala3-${{ env.RELEASE_TAG }}-aarcb64-apple-darwin.tar.gz
-          asset_name: scala3-${{ env.RELEASE_TAG }}-aarcb64-apple-darwin.tar.gz
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-aarch64-apple-darwin.tar.gz
+          asset_name: scala3-${{ env.RELEASE_TAG }}-aarch64-apple-darwin.tar.gz
           asset_content_type: application/gzip
       - name: Upload tar.gz archive SHA to GitHub Release (Mac aarch64)
         uses: actions/upload-release-asset@v1
@@ -1043,8 +1048,8 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
-          asset_path: ./scala3-${{ env.RELEASE_TAG }}-aarcb64-apple-darwin.tar.gz.sha256
-          asset_name: scala3-${{ env.RELEASE_TAG }}-aarcb64-apple-darwin.tar.gz.sha256
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}-aarch64-apple-darwin.tar.gz.sha256
+          asset_name: scala3-${{ env.RELEASE_TAG }}-aarch64-apple-darwin.tar.gz.sha256
           asset_content_type: text/plain
 
 

From bcbdb5ef52c93dd34b93294a9774fdd57d9fb2aa Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Sat, 19 Oct 2024 20:04:59 +0200
Subject: [PATCH 051/306] Prepare development setup for 3.6.2 (#21811)

- Set baseVersiont o 3.6.2
- Set referenceVersion to 3.6.1 and move `src/boostrapped` files to
`src`
- Set mimaPreviousArtifactVersion to 3.6.1 (exception from the rule due
to broken 3.6.0 release)
---
 .../{src-bootstrapped => src}/scala/NamedTuple.scala   |  0
 project/Build.scala                                    | 10 ++++++----
 2 files changed, 6 insertions(+), 4 deletions(-)
 rename library/{src-bootstrapped => src}/scala/NamedTuple.scala (100%)

diff --git a/library/src-bootstrapped/scala/NamedTuple.scala b/library/src/scala/NamedTuple.scala
similarity index 100%
rename from library/src-bootstrapped/scala/NamedTuple.scala
rename to library/src/scala/NamedTuple.scala
diff --git a/project/Build.scala b/project/Build.scala
index 5b04d623f122..3433053629f7 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -91,11 +91,12 @@ object DottyJSPlugin extends AutoPlugin {
 object Build {
   import ScaladocConfigs._
 
-  val referenceVersion = "3.5.2-RC1"
+  val referenceVersion = "3.6.1"
 
-  val baseVersion = "3.6.1"
+  val baseVersion = "3.6.2"
   // Will be required by some automation later
-  val prereleaseVersion = s"$baseVersion-RC1"
+  // TODO: Introduce automation and handling for RC versions before 3.6.2-RC1
+  // val prereleaseVersion = s"$baseVersion-RC1"
 
   // LTS or Next
   val versionLine = "Next"
@@ -113,8 +114,9 @@ object Build {
    *  For a baseVersion `3.M.P` the mimaPreviousDottyVersion should be set to:
    *   - `3.M.0`     if `P > 0`
    *   - `3.(M-1).0` if `P = 0`
+   *  3.6.1 is an exception from this rule - 3.6.0 was a broken release
    */
-  val mimaPreviousDottyVersion = "3.5.0"
+  val mimaPreviousDottyVersion = "3.6.1"
 
   /** LTS version against which we check binary compatibility.
    *

From 40956e15df0048d76d8f4e5bebac920743e00cdc Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Sat, 19 Oct 2024 23:10:00 +0200
Subject: [PATCH 052/306] Downgrade referenceVersion to 3.6.0 and add notes how
 referenceVersion should be set (#21813)

The main branch should always use a compiler with experimental tasty -
it's required for non_boostrapped tests to pass. It's required because
we cannot consume stable version of tasty from it's experimental
subversion (it's assumed that stable version > experimental version for
the same major/minor pair)

We pick 3.6.0 (released by mistake during 3.6.0-RC1) because that's the
last non-stable version pushed to Maven. Typically we would use the last
RC version

[test_non_bootstrapped]
---
 project/Build.scala | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/project/Build.scala b/project/Build.scala
index 3433053629f7..464ba4a86411 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -91,7 +91,13 @@ object DottyJSPlugin extends AutoPlugin {
 object Build {
   import ScaladocConfigs._
 
-  val referenceVersion = "3.6.1"
+  /** Version of the Scala compiler used to build the artifacts.
+   *  Reference version should track the latest version pushed to Maven:
+   *  - In main branch it should be the last RC version (using experimental TASTy required for non-bootstrapped tests)
+   *  - In release branch it should be the last stable release
+   *  3.6.0-RC1 was released as 3.6.0 - it's having and experimental TASTy version
+   */
+  val referenceVersion = "3.6.0"
 
   val baseVersion = "3.6.2"
   // Will be required by some automation later

From 654bc6c889251a9bb895d077ac43850ab234ffe4 Mon Sep 17 00:00:00 2001
From: Jentsch <d@jentsch.berlin>
Date: Sat, 19 Oct 2024 22:19:46 +0000
Subject: [PATCH 053/306] Fix scaladoc graph highlight background color in dark
 mode

Also fix two typos
---
 scaladoc/resources/dotty_res/scripts/ux.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/scaladoc/resources/dotty_res/scripts/ux.js b/scaladoc/resources/dotty_res/scripts/ux.js
index 7b875fbcef8e..97f9bf14939d 100644
--- a/scaladoc/resources/dotty_res/scripts/ux.js
+++ b/scaladoc/resources/dotty_res/scripts/ux.js
@@ -10,7 +10,7 @@ const attrsToCopy = [
 
 /**
  * @typedef {Object} SavedPageState
- * @property {Strign} mainDiv
+ * @property {String} mainDiv
  * @property {String} leftColumn
  * @property {String} title
  * @property {Record<string, string>} attrs
@@ -322,7 +322,7 @@ function attachAllListeners() {
 
   if (location.hash) {
     var target = location.hash.substring(1);
-    // setting the 'expand' class on the top-level container causes undesireable styles
+    // setting the 'expand' class on the top-level container causes undesirable styles
     // to apply to the top-level docs, so we avoid this logic for that element.
     if (target != "container") {
       var selected = document.getElementById(location.hash.substring(1));
@@ -568,7 +568,7 @@ function showGraph() {
         .attr("offset", "30%");
       radialGradient
         .append("stop")
-        .attr("stop-color", "var(--background-default)")
+        .attr("stop-color", "var(--background-main)")
         .attr("offset", "100%");
 
       var inner = svg.append("g");

From 022b1ffa21631fb96e424942ba12b49f6996ec77 Mon Sep 17 00:00:00 2001
From: Hamza Remmal <hamza@remmal.dev>
Date: Sun, 20 Oct 2024 08:45:12 +0200
Subject: [PATCH 054/306] Use bash shell when using here-strings (#21817)

<img width="1032" alt="Screenshot 2024-10-20 at 07 14 49"
src="https://github.com/user-attachments/assets/321ba7ce-9fd2-413c-aec3-14215fbee786">


[positive](https://github.com/WojciechMazur/dotty/actions/runs/11416876799/job/31768568868)
test in #21810 also uses `bash` instead of `sh`

Closes #21815
---
 .github/workflows/ci.yaml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 72f4f5559fd7..91086858c514 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -664,6 +664,7 @@ jobs:
           echo "THISBUILD_VERSION=$ver" >> $GITHUB_ENV
 
       - name: Check is version matching pattern
+        shell: bash
         run: |
           if ! grep -Eo "3\.[0-9]+\.[0-9]+-RC[0-9]+-bin-[0-9]{8}-[a-zA-Z0-9]{7}-NIGHTLY" <<< "${{ env.THISBUILD_VERSION }}"; then
             echo "Version used by compiler to publish nightly release does not match expected pattern"

From e8136b724e74c8c3661a92f2489b52a83b4aed22 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 22 Oct 2024 10:01:21 +0100
Subject: [PATCH 055/306] Avoid orphan param from default arg

---
 compiler/src/dotty/tools/dotc/typer/Namer.scala |  5 +++++
 tests/pos/i21558.orig.scala                     | 10 ++++++++++
 tests/pos/i21558.scala                          |  8 ++++++++
 3 files changed, 23 insertions(+)
 create mode 100644 tests/pos/i21558.orig.scala
 create mode 100644 tests/pos/i21558.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 6167db62fbe0..b1b94288bcbf 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -2130,6 +2130,11 @@ class Namer { typer: Typer =>
       val pt = inherited.orElse(expectedDefaultArgType).orElse(fallbackProto).widenExpr
       val tp = typedAheadRhs(pt).tpe
       if (defaultTp eq pt) && (tp frozen_<:< defaultTp) then
+        // See i21558, the default argument new A(1.0) is of type A[?T]
+        // With an uninterpolated, invariant ?T type variable.
+        // So before we return the default getter parameter type (A[? <: Double])
+        // we want to force ?T to instantiate, so it's poly is removed from the constraint
+        isFullyDefined(tp, ForceDegree.all)
         // 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
diff --git a/tests/pos/i21558.orig.scala b/tests/pos/i21558.orig.scala
new file mode 100644
index 000000000000..3a955920a1c7
--- /dev/null
+++ b/tests/pos/i21558.orig.scala
@@ -0,0 +1,10 @@
+class Base
+class A[T <: Float](val f: T) extends Base
+
+def test() = {
+  m1(new A(m2()));
+
+}
+
+def m1(x: Base) = {}
+def m2(p: A[? <: Float] = new A(1.0f)): Int = 1
diff --git a/tests/pos/i21558.scala b/tests/pos/i21558.scala
new file mode 100644
index 000000000000..80168992cea9
--- /dev/null
+++ b/tests/pos/i21558.scala
@@ -0,0 +1,8 @@
+class Base
+class A[T <: Double](val f: T) extends Base
+
+class Test:
+  def test() = m1(new A(m2()))
+
+  def m1(x: Base): Unit = {}
+  def m2(p: A[? <: Double] = new A(1.0)): Int = 2

From d0fdbfb4cace1bba61fcffc95fba4de1c236e3eb Mon Sep 17 00:00:00 2001
From: Som Snytt <som.snytt@gmail.com>
Date: Tue, 22 Oct 2024 03:00:58 -0700
Subject: [PATCH 056/306] Nowarn extension matching nonpublic member

---
 .../dotty/tools/dotc/typer/RefChecks.scala    | 23 +++++++++++--------
 tests/warn/i21816.scala                       | 17 ++++++++++++++
 2 files changed, 30 insertions(+), 10 deletions(-)
 create mode 100644 tests/warn/i21816.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
index 0a0356707048..6945dffbe2f2 100644
--- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -1169,16 +1169,19 @@ object RefChecks {
         target.nonPrivateMember(sym.name)
         .filterWithPredicate:
           member =>
-          val memberIsImplicit = member.info.hasImplicitParams
-          val paramTps =
-            if memberIsImplicit then methTp.stripPoly.firstParamTypes
-            else methTp.firstExplicitParamTypes
-
-          paramTps.isEmpty || memberIsImplicit && !methTp.hasImplicitParams || {
-            val memberParamTps = member.info.stripPoly.firstParamTypes
-            !memberParamTps.isEmpty
-            && memberParamTps.lengthCompare(paramTps) == 0
-            && memberParamTps.lazyZip(paramTps).forall((m, x) => x frozen_<:< m)
+          val memberIsPublic = (member.symbol.flags & AccessFlags).isEmpty && !member.symbol.privateWithin.exists
+          memberIsPublic && {
+            val memberIsImplicit = member.info.hasImplicitParams
+            val paramTps =
+              if memberIsImplicit then methTp.stripPoly.firstParamTypes
+              else methTp.firstExplicitParamTypes
+
+            paramTps.isEmpty || memberIsImplicit && !methTp.hasImplicitParams || {
+              val memberParamTps = member.info.stripPoly.firstParamTypes
+              !memberParamTps.isEmpty
+              && memberParamTps.lengthCompare(paramTps) == 0
+              && memberParamTps.lazyZip(paramTps).forall((m, x) => x frozen_<:< m)
+            }
           }
         .exists
       if !target.typeSymbol.denot.isAliasType && !target.typeSymbol.denot.isOpaqueAlias && hidden
diff --git a/tests/warn/i21816.scala b/tests/warn/i21816.scala
new file mode 100644
index 000000000000..9153b8b0ee2f
--- /dev/null
+++ b/tests/warn/i21816.scala
@@ -0,0 +1,17 @@
+
+case class CC(a: String, b: String) extends Iterable[String] {
+  override def iterator: Iterator[String] = Iterator(a, b)
+}
+
+trait T {
+  extension (cc: CC) def className: String = "foo"
+}
+
+object O extends T {
+  def foo = {
+    val cc = CC("a", "b")
+    println(cc.className)
+  }
+}
+
+@main def main() = O.foo

From 959f68c1259aa12734432c990d71d3fa2d99427e Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Mon, 21 Oct 2024 18:22:43 +0200
Subject: [PATCH 057/306] Warn when named tuples resemble assignments
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Nicolas Stucki <3648029+nicolasstucki@users.noreply.github.com>
Co-Authored-By: Oliver Bračevac <bracevac@users.noreply.github.com>
---
 compiler/src/dotty/tools/dotc/ast/Desugar.scala          | 9 ++++++---
 .../src/dotty/tools/dotc/reporting/ErrorMessageID.scala  | 1 +
 compiler/src/dotty/tools/dotc/reporting/messages.scala   | 9 +++++++++
 tests/warn/21681.check                                   | 7 +++++++
 tests/warn/21681.scala                                   | 3 +++
 tests/warn/21770.check                                   | 7 +++++++
 tests/warn/21770.scala                                   | 5 +++++
 7 files changed, 38 insertions(+), 3 deletions(-)
 create mode 100644 tests/warn/21681.check
 create mode 100644 tests/warn/21681.scala
 create mode 100644 tests/warn/21770.check
 create mode 100644 tests/warn/21770.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index e1a6b97fc7d3..482210845fea 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1605,9 +1605,10 @@ object desugar {
 
   /** Translate tuple expressions
    *
-   *     ()             ==>   ()
-   *     (t)            ==>   t
-   *     (t1, ..., tN)  ==>   TupleN(t1, ..., tN)
+   *     ()                       ==>   ()
+   *     (t)                      ==>   t
+   *     (t1, ..., tN)            ==>   TupleN(t1, ..., tN)
+   *     (n1 = t1, ..., nN = tN)  ==>   NamedTuple.build[(n1, ..., nN)]()(TupleN(t1, ..., tN))
    */
   def tuple(tree: Tuple, pt: Type)(using Context): Tree =
     var elems = checkWellFormedTupleElems(tree.trees)
@@ -1638,6 +1639,8 @@ object desugar {
       if ctx.mode.is(Mode.Type) then
         AppliedTypeTree(ref(defn.NamedTupleTypeRef), namesTuple :: tup :: Nil)
       else
+        if names.length == 1 && ctx.scope.lookup(names.head).is(Flags.Mutable) then
+          report.migrationWarning(AmbiguousNamedTupleAssignment(names.head, elemValues.head), tree.srcPos)
         Apply(
           Apply(
             TypeApply(
diff --git a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
index db523c879ea2..6d0a85b3ef0f 100644
--- a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
@@ -216,6 +216,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case FinalLocalDefID // errorNumber: 200
   case NonNamedArgumentInJavaAnnotationID // errorNumber: 201
   case QuotedTypeMissingID // errorNumber: 202
+  case AmbiguousNamedTupleAssignmentID // errorNumber: 203
 
   def errorNumber = ordinal - 1
 
diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index 97cd70113c2e..3b7fba1cb52d 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -3343,3 +3343,12 @@ final class QuotedTypeMissing(tpe: Type)(using Context) extends StagingMessage(Q
         |"""
 
 end QuotedTypeMissing
+
+final class AmbiguousNamedTupleAssignment(key: Name, value: untpd.Tree)(using Context) extends SyntaxMsg(AmbiguousNamedTupleAssignmentID):
+  override protected def msg(using Context): String =
+    i"""Ambiguous syntax: this is interpreted as a named tuple with one element,
+      |not as an assignment.
+      |
+      |To assign a value, use curly braces: `{${key} = ${value}}`."""
+  
+  override protected def explain(using Context): String = ""
diff --git a/tests/warn/21681.check b/tests/warn/21681.check
new file mode 100644
index 000000000000..e86ce4e36134
--- /dev/null
+++ b/tests/warn/21681.check
@@ -0,0 +1,7 @@
+-- [E203] Syntax Migration Warning: tests/warn/21681.scala:3:2 ---------------------------------------------------------
+3 |  (age = 29) // warn
+  |  ^^^^^^^^^^
+  |  Ambiguous syntax: this is interpreted as a named tuple with one element,
+  |  not as an assignment.
+  |
+  |  To assign a value, use curly braces: `{age = 29}`.
diff --git a/tests/warn/21681.scala b/tests/warn/21681.scala
new file mode 100644
index 000000000000..76a19c96e1cb
--- /dev/null
+++ b/tests/warn/21681.scala
@@ -0,0 +1,3 @@
+def main() =
+  var age: Int = 28
+  (age = 29) // warn
diff --git a/tests/warn/21770.check b/tests/warn/21770.check
new file mode 100644
index 000000000000..0899f11d6ca5
--- /dev/null
+++ b/tests/warn/21770.check
@@ -0,0 +1,7 @@
+-- [E203] Syntax Migration Warning: tests/warn/21770.scala:5:9 ---------------------------------------------------------
+5 |  f(i => (cache = Some(i))) // warn
+  |         ^^^^^^^^^^^^^^^^^
+  |         Ambiguous syntax: this is interpreted as a named tuple with one element,
+  |         not as an assignment.
+  |
+  |         To assign a value, use curly braces: `{cache = Some(i)}`.
diff --git a/tests/warn/21770.scala b/tests/warn/21770.scala
new file mode 100644
index 000000000000..9696a31d6ba8
--- /dev/null
+++ b/tests/warn/21770.scala
@@ -0,0 +1,5 @@
+def f(g: Int  => Unit) = g(0)
+
+def test = 
+  var cache: Option[Int] = None
+  f(i => (cache = Some(i))) // warn

From a00a806361666822c2a8098c2f45f8b93df15483 Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Mon, 21 Oct 2024 19:51:53 +0200
Subject: [PATCH 058/306] Move AmbiguousNamedTupleAssignment check to Typer
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Nicolas Stucki <3648029+nicolasstucki@users.noreply.github.com>
Co-Authored-By: Oliver Bračevac <bracevac@users.noreply.github.com>
---
 compiler/src/dotty/tools/dotc/ast/Desugar.scala |  2 --
 compiler/src/dotty/tools/dotc/typer/Typer.scala | 13 +++++++++++++
 tests/pos/21681d.scala                          | 16 ++++++++++++++++
 tests/warn/21681b.check                         |  7 +++++++
 tests/warn/21681b.scala                         |  3 +++
 5 files changed, 39 insertions(+), 2 deletions(-)
 create mode 100644 tests/pos/21681d.scala
 create mode 100644 tests/warn/21681b.check
 create mode 100644 tests/warn/21681b.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 482210845fea..e66c71731b4f 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1639,8 +1639,6 @@ object desugar {
       if ctx.mode.is(Mode.Type) then
         AppliedTypeTree(ref(defn.NamedTupleTypeRef), namesTuple :: tup :: Nil)
       else
-        if names.length == 1 && ctx.scope.lookup(names.head).is(Flags.Mutable) then
-          report.migrationWarning(AmbiguousNamedTupleAssignment(names.head, elemValues.head), tree.srcPos)
         Apply(
           Apply(
             TypeApply(
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 89ce01231fed..e7bd7d874634 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -3398,6 +3398,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   /** Translate tuples of all arities */
   def typedTuple(tree: untpd.Tuple, pt: Type)(using Context): Tree =
     val tree1 = desugar.tuple(tree, pt)
+    checkAmbiguousNamedTupleAssignment(tree)
     if tree1 ne tree then typed(tree1, pt)
     else
       val arity = tree.trees.length
@@ -3423,6 +3424,18 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           val resTpe = TypeOps.nestedPairs(elemTpes)
           app1.cast(resTpe)
 
+ /** Checks if `tree` is a named tuple with one element that could be
+  *  interpreted as an assignment, such as `(x = 1)`. If so, issues a warning.
+  */
+  def checkAmbiguousNamedTupleAssignment(tree: untpd.Tuple)(using Context): Unit =
+    tree.trees match
+      case List(NamedArg(name, value)) =>
+        val typedName = typedIdent(untpd.Ident(name), WildcardType)
+        val sym = typedName.symbol
+        if sym.exists && (sym.is(Flags.Mutable) || sym.setter.exists) then
+          report.migrationWarning(AmbiguousNamedTupleAssignment(name, value), tree.srcPos)
+      case _ => ()
+
   /** Retrieve symbol attached to given tree */
   protected def retrieveSym(tree: untpd.Tree)(using Context): Symbol = tree.removeAttachment(SymOfTree) match {
     case Some(sym) =>
diff --git a/tests/pos/21681d.scala b/tests/pos/21681d.scala
new file mode 100644
index 000000000000..97a01dec74aa
--- /dev/null
+++ b/tests/pos/21681d.scala
@@ -0,0 +1,16 @@
+def test1() =
+  class Person:
+    def age: Int = ???
+    def age_=(x: Int): Unit = ???
+
+  val person = Person()
+  
+  (person.age = 29) // no warn (interpreted as `person.age_=(29)`)
+
+def test2() =
+  class Person:
+    var age: Int = 28
+
+  val person = Person()
+  
+  (person.age = 29) // no warn (interpreted as `person.age_=(29)`)
diff --git a/tests/warn/21681b.check b/tests/warn/21681b.check
new file mode 100644
index 000000000000..32760e00ebb6
--- /dev/null
+++ b/tests/warn/21681b.check
@@ -0,0 +1,7 @@
+-- [E203] Syntax Migration Warning: tests/warn/21681b.scala:3:2 --------------------------------------------------------
+3 |  (age = 29) // warn
+  |  ^^^^^^^^^^
+  |  Ambiguous syntax: this is interpreted as a named tuple with one element,
+  |  not as an assignment.
+  |
+  |  To assign a value, use curly braces: `{age = 29}`.
diff --git a/tests/warn/21681b.scala b/tests/warn/21681b.scala
new file mode 100644
index 000000000000..710d69b0dd23
--- /dev/null
+++ b/tests/warn/21681b.scala
@@ -0,0 +1,3 @@
+object Test:
+  var age: Int = 28
+  (age = 29) // warn

From d1e68f19c99d4171f0c4a6f17cef0ceb72a20bd8 Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Tue, 22 Oct 2024 14:09:45 +0200
Subject: [PATCH 059/306] Try to type as an `Assign`

---
 compiler/src/dotty/tools/dotc/typer/Typer.scala | 8 +++++---
 tests/warn/21681c.check                         | 7 +++++++
 tests/warn/21681c.scala                         | 5 +++++
 3 files changed, 17 insertions(+), 3 deletions(-)
 create mode 100644 tests/warn/21681c.check
 create mode 100644 tests/warn/21681c.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index e7bd7d874634..23855455e67b 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -3430,9 +3430,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   def checkAmbiguousNamedTupleAssignment(tree: untpd.Tuple)(using Context): Unit =
     tree.trees match
       case List(NamedArg(name, value)) =>
-        val typedName = typedIdent(untpd.Ident(name), WildcardType)
-        val sym = typedName.symbol
-        if sym.exists && (sym.is(Flags.Mutable) || sym.setter.exists) then
+        val tmpCtx = ctx.fresh.setNewTyperState()
+        typedAssign(untpd.Assign(untpd.Ident(name), value), WildcardType)(using tmpCtx)
+        if !tmpCtx.reporter.hasErrors then
+          // If there are no errors typing the above, then the named tuple is
+          // ambiguous and we issue a warning.
           report.migrationWarning(AmbiguousNamedTupleAssignment(name, value), tree.srcPos)
       case _ => ()
 
diff --git a/tests/warn/21681c.check b/tests/warn/21681c.check
new file mode 100644
index 000000000000..11c427f87cfe
--- /dev/null
+++ b/tests/warn/21681c.check
@@ -0,0 +1,7 @@
+-- [E203] Syntax Migration Warning: tests/warn/21681c.scala:5:2 --------------------------------------------------------
+5 |  (age = 29) // warn
+  |  ^^^^^^^^^^
+  |  Ambiguous syntax: this is interpreted as a named tuple with one element,
+  |  not as an assignment.
+  |
+  |  To assign a value, use curly braces: `{age = 29}`.
diff --git a/tests/warn/21681c.scala b/tests/warn/21681c.scala
new file mode 100644
index 000000000000..5e2eae11708c
--- /dev/null
+++ b/tests/warn/21681c.scala
@@ -0,0 +1,5 @@
+object Test:
+  def age: Int = ???
+  def age_=(x: Int): Unit = ()
+  age = 29
+  (age = 29) // warn

From ae1b583325a160ed980808be7915c1adb66ac22a Mon Sep 17 00:00:00 2001
From: Som Snytt <som.snytt@gmail.com>
Date: Tue, 22 Oct 2024 08:04:10 -0700
Subject: [PATCH 060/306] Prefer isPublic in RefChecks

---
 compiler/src/dotty/tools/dotc/typer/RefChecks.scala | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
index 6945dffbe2f2..0ec9458cac5c 100644
--- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -525,7 +525,6 @@ object RefChecks {
 
       // 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)
@@ -534,7 +533,7 @@ object RefChecks {
           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)
+        member.isPublic || protectedOK && (accessBoundaryOK || otherIsJavaProtected)
       end isOverrideAccessOK
 
       if !member.hasTargetName(other.targetName) then
@@ -1169,8 +1168,7 @@ object RefChecks {
         target.nonPrivateMember(sym.name)
         .filterWithPredicate:
           member =>
-          val memberIsPublic = (member.symbol.flags & AccessFlags).isEmpty && !member.symbol.privateWithin.exists
-          memberIsPublic && {
+          member.symbol.isPublic && {
             val memberIsImplicit = member.info.hasImplicitParams
             val paramTps =
               if memberIsImplicit then methTp.stripPoly.firstParamTypes

From ecc332fe6feccb893226c5705038772fb36b9f9b Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Tue, 22 Oct 2024 18:56:56 +0200
Subject: [PATCH 061/306] Scala 2 forwardport: `-Yprofile-trace` (#19897)

* Scala 2 tracing profiler backport from
https://github.com/scala/scala/pull/7364 extended with more Scala 3
idiomatic syntax based on inlined methods
* Fixes the `context.profiler` which could have been `null`, now it's
initially a NoOp Profiler
* Check dependencies of `-Yprofile-enabled` dependent tasks, now we get
an error if `-Yprofile-trace` is set without `-Yprofile-enabled`
---
 compiler/src/dotty/tools/dotc/Compiler.scala  |   5 +-
 compiler/src/dotty/tools/dotc/Run.scala       |   7 +-
 .../tools/dotc/config/ScalaSettings.scala     |  10 +-
 .../dotty/tools/dotc/config/Settings.scala    |  15 +-
 .../src/dotty/tools/dotc/core/Contexts.scala  |   1 +
 .../src/dotty/tools/dotc/core/Phases.scala    |   2 +-
 .../dotty/tools/dotc/core/SymbolLoaders.scala |  12 +-
 .../tools/dotc/profile/ChromeTrace.scala      | 190 +++++++++++++
 .../dotty/tools/dotc/profile/FileUtils.scala  | 204 ++++++++++++++
 .../dotty/tools/dotc/profile/Profiler.scala   | 256 ++++++++++++++----
 .../dotc/profile/ThreadPoolFactory.scala      |   4 +-
 .../dotty/tools/dotc/transform/Splicer.scala  |   5 +-
 .../dotty/tools/dotc/typer/Implicits.scala    |   2 +-
 .../src/dotty/tools/dotc/typer/Typer.scala    |   8 +-
 .../dotty/tools/dotc/typer/TyperPhase.scala   |   2 +-
 .../tools/dotc/profile/ChromeTraceTest.scala  |  93 +++++++
 .../tools/dotc/profile/FileUtilsTest.scala    |  91 +++++++
 .../pc/completions/CompletionProvider.scala   |   6 +-
 18 files changed, 835 insertions(+), 78 deletions(-)
 create mode 100644 compiler/src/dotty/tools/dotc/profile/ChromeTrace.scala
 create mode 100644 compiler/src/dotty/tools/dotc/profile/FileUtils.scala
 create mode 100644 compiler/test/dotty/tools/dotc/profile/ChromeTraceTest.scala
 create mode 100644 compiler/test/dotty/tools/dotc/profile/FileUtilsTest.scala

diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala
index f9503e4f8554..d8ba1ab5dc2e 100644
--- a/compiler/src/dotty/tools/dotc/Compiler.scala
+++ b/compiler/src/dotty/tools/dotc/Compiler.scala
@@ -152,7 +152,10 @@ class Compiler {
     List(new GenBCode) ::             // Generate JVM bytecode
     Nil
 
-  var runId: Int = 1
+  // TODO: Initially 0, so that the first nextRunId call would return InitialRunId == 1
+  // Changing the initial runId from 1 to 0 makes the scala2-library-bootstrap fail to compile,
+  // when the underlying issue is fixed, please update dotc.profiler.RealProfiler.chromeTrace logic
+  private var runId: Int = 1
   def nextRunId: Int = {
     runId += 1; runId
   }
diff --git a/compiler/src/dotty/tools/dotc/Run.scala b/compiler/src/dotty/tools/dotc/Run.scala
index 11a0430480d9..50fd668c7696 100644
--- a/compiler/src/dotty/tools/dotc/Run.scala
+++ b/compiler/src/dotty/tools/dotc/Run.scala
@@ -339,10 +339,9 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
         if phaseWillRun then
           Stats.trackTime(s"phase time ms/$phase") {
             val start = System.currentTimeMillis
-            val profileBefore = profiler.beforePhase(phase)
-            try units = phase.runOn(units)
-            catch case _: InterruptedException => cancelInterrupted()
-            profiler.afterPhase(phase, profileBefore)
+            profiler.onPhase(phase):
+              try units = phase.runOn(units)
+              catch case _: InterruptedException => cancelInterrupted()
             if (ctx.settings.Xprint.value.containsPhase(phase))
               for (unit <- units)
                 def printCtx(unit: CompilationUnit) = phase.printingContext(
diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
index 72a051ea8154..6ef33d24f8be 100644
--- a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
+++ b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
@@ -441,12 +441,10 @@ private sealed trait YSettings:
   val YlegacyLazyVals: Setting[Boolean] = BooleanSetting(ForkSetting, "Ylegacy-lazy-vals", "Use legacy (pre 3.3.0) implementation of lazy vals.")
   val YcompileScala2Library: Setting[Boolean] = BooleanSetting(ForkSetting, "Ycompile-scala2-library", "Used when compiling the Scala 2 standard library.")
   val YprofileEnabled: Setting[Boolean] = BooleanSetting(ForkSetting, "Yprofile-enabled", "Enable profiling.")
-  val YprofileDestination: Setting[String] = StringSetting(ForkSetting, "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(ForkSetting, "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(ForkSetting, "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 )
+  val YprofileDestination: Setting[String] = StringSetting(ForkSetting, "Yprofile-destination", "file", "Where to send profiling output - specify a file, default is to the console.", "", depends = List(YprofileEnabled -> true))
+  val YprofileExternalTool: Setting[List[String]] = PhasesSetting(ForkSetting, "Yprofile-external-tool", "Enable profiling for a phase using an external tool hook. Generally only useful for a single phase.", "typer", depends = List(YprofileEnabled -> true))
+  val YprofileRunGcBetweenPhases: Setting[List[String]] = PhasesSetting(ForkSetting, "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 *", "_", depends = List(YprofileEnabled -> true))
+  val YprofileTrace: Setting[String]  = StringSetting(ForkSetting, "Yprofile-trace", "file", s"Capture trace of compilation in JSON Chrome Trace format to the specified file. This option requires ${YprofileEnabled.name}. The output file can be visualized using https://ui.perfetto.dev/.", "", depends = List(YprofileEnabled -> true))
 
   val YbestEffort: Setting[Boolean] = BooleanSetting(ForkSetting, "Ybest-effort", "Enable best-effort compilation attempting to produce betasty to the META-INF/best-effort directory, regardless of errors, as part of the pickler phase.")
   val YwithBestEffortTasty: Setting[Boolean] = BooleanSetting(ForkSetting, "Ywith-best-effort-tasty", "Allow to compile using best-effort tasty files. If such file is used, the compiler will stop after the pickler phase.")
diff --git a/compiler/src/dotty/tools/dotc/config/Settings.scala b/compiler/src/dotty/tools/dotc/config/Settings.scala
index a5fc6a64aa45..f85f2cc57de4 100644
--- a/compiler/src/dotty/tools/dotc/config/Settings.scala
+++ b/compiler/src/dotty/tools/dotc/config/Settings.scala
@@ -73,6 +73,11 @@ object Settings:
   def validateSettingString(name: String): Unit =
     assert(settingCharacters.matches(name), s"Setting string $name contains invalid characters")
 
+  /** List of setting-value pairs that are required for another setting to be valid.
+    * For example, `s = Setting(..., depends = List(YprofileEnabled -> true))`
+    * means that `s` requires `YprofileEnabled` to be set to `true`.
+    */
+  type SettingDependencies = List[(Setting[?], Any)]
 
   case class Setting[T: ClassTag] private[Settings] (
     category: SettingCategory,
@@ -83,7 +88,7 @@ object Settings:
     choices: Option[Seq[?]] = None,
     prefix: Option[String] = None,
     aliases: List[String] = Nil,
-    depends: List[(Setting[?], Any)] = Nil,
+    depends: SettingDependencies = Nil,
     ignoreInvalidArgs: Boolean = false,
     preferPrevious: Boolean = false,
     propertyClass: Option[Class[?]] = None,
@@ -385,8 +390,8 @@ object Settings:
     def BooleanSetting(category: SettingCategory, name: String, descr: String, initialValue: Boolean = false, aliases: List[String] = Nil, preferPrevious: Boolean = false, deprecation: Option[Deprecation] = None, ignoreInvalidArgs: Boolean = false): Setting[Boolean] =
       publish(Setting(category, prependName(name), descr, initialValue, aliases = aliases, preferPrevious = preferPrevious, deprecation = deprecation, ignoreInvalidArgs = ignoreInvalidArgs))
 
-    def StringSetting(category: SettingCategory, name: String, helpArg: String, descr: String, default: String, aliases: List[String] = Nil, deprecation: Option[Deprecation] = None): Setting[String] =
-      publish(Setting(category, prependName(name), descr, default, helpArg, aliases = aliases, deprecation = deprecation))
+    def StringSetting(category: SettingCategory, name: String, helpArg: String, descr: String, default: String, aliases: List[String] = Nil, deprecation: Option[Deprecation] = None, depends: SettingDependencies = Nil): Setting[String] =
+      publish(Setting(category, prependName(name), descr, default, helpArg, aliases = aliases, deprecation = deprecation, depends = depends))
 
     def ChoiceSetting(category: SettingCategory, name: String, helpArg: String, descr: String, choices: List[String], default: String, aliases: List[String] = Nil, legacyArgs: Boolean = false, deprecation: Option[Deprecation] = None): Setting[String] =
       publish(Setting(category, prependName(name), descr, default, helpArg, Some(choices), aliases = aliases, legacyArgs = legacyArgs, deprecation = deprecation))
@@ -412,8 +417,8 @@ object Settings:
     def PathSetting(category: SettingCategory, name: String, descr: String, default: String, aliases: List[String] = Nil, deprecation: Option[Deprecation] = None): Setting[String] =
       publish(Setting(category, prependName(name), descr, default, aliases = aliases, deprecation = deprecation))
 
-    def PhasesSetting(category: SettingCategory, name: String, descr: String, default: String = "", aliases: List[String] = Nil, deprecation: Option[Deprecation] = None): Setting[List[String]] =
-      publish(Setting(category, prependName(name), descr, if (default.isEmpty) Nil else List(default), aliases = aliases, deprecation = deprecation))
+    def PhasesSetting(category: SettingCategory, name: String, descr: String, default: String = "", aliases: List[String] = Nil, deprecation: Option[Deprecation] = None, depends: SettingDependencies = Nil): Setting[List[String]] =
+      publish(Setting(category, prependName(name), descr, if (default.isEmpty) Nil else List(default), aliases = aliases, deprecation = deprecation, depends = depends))
 
     def PrefixSetting(category: SettingCategory, name0: String, descr: String, deprecation: Option[Deprecation] = None): Setting[List[String]] =
       val name = prependName(name0)
diff --git a/compiler/src/dotty/tools/dotc/core/Contexts.scala b/compiler/src/dotty/tools/dotc/core/Contexts.scala
index 388720e7f3f4..d69c7408d0b1 100644
--- a/compiler/src/dotty/tools/dotc/core/Contexts.scala
+++ b/compiler/src/dotty/tools/dotc/core/Contexts.scala
@@ -769,6 +769,7 @@ object Contexts {
           .updated(settingsStateLoc, settingsGroup.defaultState)
           .updated(notNullInfosLoc, Nil)
           .updated(compilationUnitLoc, NoCompilationUnit)
+          .updated(profilerLoc, Profiler.NoOp)
       c._searchHistory = new SearchRoot
       c._gadtState = GadtState(GadtConstraint.empty)
       c
diff --git a/compiler/src/dotty/tools/dotc/core/Phases.scala b/compiler/src/dotty/tools/dotc/core/Phases.scala
index 85df3f9f2c18..015cf6fc0f2c 100644
--- a/compiler/src/dotty/tools/dotc/core/Phases.scala
+++ b/compiler/src/dotty/tools/dotc/core/Phases.scala
@@ -370,7 +370,7 @@ object Phases {
       // Test that we are in a state where we need to check if the phase should be skipped for a java file,
       // this prevents checking the expensive `unit.typedAsJava` unnecessarily.
       val doCheckJava = skipIfJava && !isAfterLastJavaPhase
-      for unit <- units do
+      for unit <- units do ctx.profiler.onUnit(this, unit):
         given unitCtx: Context = runCtx.fresh.setPhase(this.start).setCompilationUnit(unit).withRootImports
         if ctx.run.enterUnit(unit) then
           try
diff --git a/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala b/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
index 51e6a5e6138a..5690720a1b3f 100644
--- a/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
@@ -8,7 +8,7 @@ import java.nio.channels.ClosedByInterruptException
 import scala.util.control.NonFatal
 
 import dotty.tools.dotc.classpath.FileUtils.{hasTastyExtension, hasBetastyExtension}
-import dotty.tools.io.{ ClassPath, ClassRepresentation, AbstractFile }
+import dotty.tools.io.{ ClassPath, ClassRepresentation, AbstractFile, NoAbstractFile }
 import dotty.tools.backend.jvm.DottyBackendInterface.symExtensions
 
 import Contexts.*, Symbols.*, Flags.*, SymDenotations.*, Types.*, Scopes.*, Names.*
@@ -333,7 +333,15 @@ abstract class SymbolLoader extends LazyType { self =>
     def description(using Context): String = s"proxy to ${self.description}"
   }
 
-  override def complete(root: SymDenotation)(using Context): Unit = {
+  private inline def profileCompletion[T](root: SymDenotation)(inline body: T)(using Context): T = {
+    val sym = root.symbol
+    def associatedFile = root.symbol.associatedFile match
+      case file: AbstractFile => file
+      case _ => NoAbstractFile
+    ctx.profiler.onCompletion(sym, associatedFile)(body)
+  }
+
+  override def complete(root: SymDenotation)(using Context): Unit = profileCompletion(root) {
     def signalError(ex: Exception): Unit = {
       if (ctx.debug) ex.printStackTrace()
       val msg = ex.getMessage()
diff --git a/compiler/src/dotty/tools/dotc/profile/ChromeTrace.scala b/compiler/src/dotty/tools/dotc/profile/ChromeTrace.scala
new file mode 100644
index 000000000000..c33039f46398
--- /dev/null
+++ b/compiler/src/dotty/tools/dotc/profile/ChromeTrace.scala
@@ -0,0 +1,190 @@
+// Scala 2 compiler backport of https://github.com/scala/scala/pull/7364
+/*
+ * 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.profile
+
+import scala.language.unsafeNulls
+
+import java.io.Closeable
+import java.lang.management.ManagementFactory
+import java.nio.file.{Files, Path}
+import java.util
+import java.util.concurrent.TimeUnit
+
+import scala.collection.mutable
+
+object ChromeTrace {
+  private object EventType {
+    final val Start = "B"
+    final val Instant = "I"
+    final val End = "E"
+    final val Complete = "X"
+
+    final val Counter = "C"
+
+    final val AsyncStart = "b"
+    final val AsyncInstant = "n"
+    final val AsyncEnd = "e"
+  }
+}
+
+/** Allows writing a subset of captrue traces based on https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview#
+  * Can be visualized using https://ui.perfetto.dev/, Chrome's about://tracing (outdated) or the tooling in https://www.google.com.au/search?q=catapult+tracing&oq=catapult+tracing+&aqs=chrome..69i57.3974j0j4&sourceid=chrome&ie=UTF-8 */
+final class ChromeTrace(f: Path) extends Closeable {
+  import ChromeTrace.EventType
+  private val traceWriter = FileUtils.newAsyncBufferedWriter(f)
+  private val context = mutable.Stack[JsonContext](TopContext)
+  private val tidCache = new ThreadLocal[String]() {
+    override def initialValue(): String = "%05d".format(Thread.currentThread().getId())
+  }
+  objStart()
+  fld("traceEvents")
+  context.push(ValueContext)
+  arrStart()
+  traceWriter.newLine()
+
+  private val pid = ManagementFactory.getRuntimeMXBean().getName().replaceAll("@.*", "")
+
+  override def close(): Unit = {
+    arrEnd()
+    objEnd()
+    context.pop()
+    tidCache.remove()
+    traceWriter.close()
+  }
+
+  def traceDurationEvent(name: String, startNanos: Long, durationNanos: Long, tid: String = this.tid(), pidSuffix: String = ""): Unit = {
+    val durationMicros = nanosToMicros(durationNanos)
+    val startMicros = nanosToMicros(startNanos)
+    objStart()
+    str("cat", "scalac")
+    str("name", name)
+    str("ph", EventType.Complete)
+    str("tid", tid)
+    writePid(pidSuffix)
+    lng("ts", startMicros)
+    lng("dur", durationMicros)
+    objEnd()
+    traceWriter.newLine()
+  }
+
+  private def writePid(pidSuffix: String) = {
+    if (pidSuffix == "")
+      str("pid", pid)
+    else
+      str2("pid", pid, "-", pidSuffix)
+  }
+
+  def traceCounterEvent(name: String, counterName: String, count: Long, processWide: Boolean): Unit = {
+    objStart()
+    str("cat", "scalac")
+    str("name", name)
+    str("ph", EventType.Counter)
+    str("tid", tid())
+    writePid(pidSuffix = if (processWide) "" else tid())
+    lng("ts", microTime())
+    fld("args")
+    objStart()
+    lng(counterName, count)
+    objEnd()
+    objEnd()
+    traceWriter.newLine()
+  }
+
+  def traceDurationEventStart(cat: String, name: String, colour: String = "", pidSuffix: String = tid()): Unit = traceDurationEventStartEnd(EventType.Start, cat, name, colour, pidSuffix)
+  def traceDurationEventEnd(cat: String, name: String, colour: String = "", pidSuffix: String = tid()): Unit = traceDurationEventStartEnd(EventType.End, cat, name, colour, pidSuffix)
+
+  private def traceDurationEventStartEnd(eventType: String, cat: String, name: String, colour: String, pidSuffix: String = ""): Unit = {
+    objStart()
+    str("cat", cat)
+    str("name", name)
+    str("ph", eventType)
+    writePid(pidSuffix)
+    str("tid", tid())
+    lng("ts", microTime())
+    if (colour != "") {
+      str("cname", colour)
+    }
+    objEnd()
+    traceWriter.newLine()
+  }
+
+  private def tid(): String = tidCache.get()
+
+  private def nanosToMicros(t: Long): Long = TimeUnit.NANOSECONDS.toMicros(t)
+
+  private def microTime(): Long = nanosToMicros(System.nanoTime())
+
+  private sealed abstract class JsonContext
+  private case class ArrayContext(var first: Boolean) extends JsonContext
+  private case class ObjectContext(var first: Boolean) extends JsonContext
+  private case object ValueContext extends JsonContext
+  private case object TopContext extends JsonContext
+
+  private def str(name: String, value: String): Unit = {
+    fld(name)
+    traceWriter.write("\"")
+    traceWriter.write(value) // This assumes no escaping is needed
+    traceWriter.write("\"")
+  }
+  private def str2(name: String, value: String, valueContinued1: String, valueContinued2: String): Unit = {
+    fld(name)
+    traceWriter.write("\"")
+    traceWriter.write(value) // This assumes no escaping is needed
+    traceWriter.write(valueContinued1) // This assumes no escaping is needed
+    traceWriter.write(valueContinued2) // This assumes no escaping is needed
+    traceWriter.write("\"")
+  }
+  private def lng(name: String, value: Long): Unit = {
+    fld(name)
+    traceWriter.write(String.valueOf(value))
+    traceWriter.write("")
+  }
+  private def objStart(): Unit = {
+    context.top match {
+      case ac @ ArrayContext(first) =>
+        if (first) ac.first = false
+        else traceWriter.write(",")
+      case _ =>
+    }
+    context.push(ObjectContext(true))
+    traceWriter.write("{")
+  }
+  private def objEnd(): Unit = {
+    traceWriter.write("}")
+    context.pop()
+  }
+  private def arrStart(): Unit = {
+    traceWriter.write("[")
+    context.push(ArrayContext(true))
+  }
+  private def arrEnd(): Unit = {
+    traceWriter.write("]")
+    context.pop()
+  }
+
+  private def fld(name: String) = {
+    val topContext = context.top
+    topContext match {
+      case oc @ ObjectContext(first) =>
+        if (first) oc.first = false
+        else traceWriter.write(",")
+      case context =>
+        throw new IllegalStateException("Wrong context: " + context)
+    }
+    traceWriter.write("\"")
+    traceWriter.write(name)
+    traceWriter.write("\"")
+    traceWriter.write(":")
+  }
+}
\ No newline at end of file
diff --git a/compiler/src/dotty/tools/dotc/profile/FileUtils.scala b/compiler/src/dotty/tools/dotc/profile/FileUtils.scala
new file mode 100644
index 000000000000..4aec428c05bf
--- /dev/null
+++ b/compiler/src/dotty/tools/dotc/profile/FileUtils.scala
@@ -0,0 +1,204 @@
+// Scala 2 compiler backport of https://github.com/scala/scala/pull/7364
+
+/*
+* 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.profile
+
+import scala.language.unsafeNulls
+
+import java.io.{BufferedWriter, IOException, OutputStreamWriter, Writer}
+import java.nio.CharBuffer
+import java.nio.charset.{Charset, CharsetEncoder, StandardCharsets}
+import java.nio.file.{Files, OpenOption, Path}
+import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.atomic.AtomicBoolean
+
+
+import scala.concurrent.duration.Duration
+import scala.concurrent.{Await, Promise}
+import scala.util.{Failure, Success}
+import scala.annotation.internal.sharable
+
+object FileUtils {
+  def newAsyncBufferedWriter(path: Path, charset: Charset = StandardCharsets.UTF_8.nn, options: Array[OpenOption] = NO_OPTIONS, threadsafe: Boolean = false): LineWriter = {
+    val encoder: CharsetEncoder = charset.newEncoder
+    val writer = new OutputStreamWriter(Files.newOutputStream(path, options: _*), encoder)
+    newAsyncBufferedWriter(new BufferedWriter(writer), threadsafe)
+  }
+  def newAsyncBufferedWriter(underlying: Writer, threadsafe: Boolean): LineWriter = {
+    val async = new AsyncBufferedWriter(underlying)
+    if (threadsafe) new ThreadsafeWriter(async) else async
+  }
+  private val NO_OPTIONS = new Array[OpenOption](0)
+
+  sealed abstract class LineWriter extends Writer {
+    def newLine(): Unit
+  }
+  private class ThreadsafeWriter(val underlying: AsyncBufferedWriter) extends LineWriter {
+    lock = underlying
+    override def write(c: Int): Unit =
+      lock.synchronized (underlying.write(c))
+
+    override def write(cbuf: Array[Char]): Unit =
+      lock.synchronized (underlying.write(cbuf))
+
+    override def write(cbuf: Array[Char], off: Int, len: Int): Unit =
+      lock.synchronized (underlying.write(cbuf, off, len))
+
+    override def write(str: String): Unit =
+      lock.synchronized (underlying.write(str))
+
+    override def write(str: String, off: Int, len: Int): Unit =
+      lock.synchronized (underlying.write(str, off, len))
+
+    override def flush(): Unit =
+      lock.synchronized (underlying.flush())
+
+    override def close(): Unit =
+      lock.synchronized (underlying.close())
+
+    override def newLine(): Unit =
+      lock.synchronized (underlying.newLine())
+
+  }
+
+  private object AsyncBufferedWriter {
+    @sharable private val Close = CharBuffer.allocate(0)
+    @sharable private val Flush = CharBuffer.allocate(0)
+  }
+  private class AsyncBufferedWriter(val underlying: Writer, bufferSize : Int = 4096) extends LineWriter {
+    private var current: CharBuffer = allocate
+    override def write(c: Int): Unit = super.write(c)
+    private def flushAsync(): Unit = {
+      background.ensureProcessed(current)
+      current = allocate
+    }
+//    allocate or reuse a CharArray which is guaranteed to have a backing array
+    private def allocate: CharBuffer = {
+      val reused = background.reuseBuffer
+      if (reused eq null)      CharBuffer.allocate(bufferSize)
+      else {
+        //we don't care about race conditions
+        background.reuseBuffer = null
+        reused.clear()
+        reused
+      }
+    }
+
+    override def write(cbuf: Array[Char], initialOffset: Int, initialLength: Int): Unit = {
+      var offset = initialOffset
+      var length = initialLength
+      while (length > 0) {
+        val capacity = current.remaining()
+        if (length <= capacity) {
+          current.put(cbuf, offset, length)
+          length = 0
+        } else {
+          current.put(cbuf, offset, capacity)
+          flushAsync()
+          length -= capacity
+          offset += capacity
+        }
+      }
+    }
+
+    override def write(s: String,  initialOffset: Int, initialLength: Int): Unit = {
+      var offset = initialOffset
+      var length = initialLength
+      while (length > 0) {
+        val capacity = current.remaining()
+        if (length <= capacity) {
+          current.put(s, offset, offset + length)
+          length = 0
+        } else {
+          current.put(s, offset, offset + capacity)
+          flushAsync()
+          length -= capacity
+          offset += capacity
+        }
+      }
+    }
+
+    def newLine(): Unit = write(scala.util.Properties.lineSeparator)
+
+    /** slightly breaks the flush contract in that the flush is not complete when the method returns */
+    override def flush(): Unit = {
+      flushAsync()
+    }
+
+    override def close(): Unit = {
+      background.ensureProcessed(current)
+      background.ensureProcessed(AsyncBufferedWriter.Close)
+      current = null
+      Await.result(background.asyncStatus.future, Duration.Inf)
+      underlying.close()
+    }
+    private object background extends Runnable{
+
+      import scala.concurrent.ExecutionContext.Implicits.global
+
+      private val pending = new LinkedBlockingQueue[CharBuffer]
+      //a failure detected will case an Failure, Success indicates a close
+      val asyncStatus = Promise[Unit]()
+      private val scheduled = new AtomicBoolean
+      @volatile var reuseBuffer: CharBuffer = _
+
+      def ensureProcessed(buffer: CharBuffer): Unit = {
+        if (asyncStatus.isCompleted) {
+          asyncStatus.future.value.get match {
+            case Success(()) => throw new IllegalStateException("closed")
+            case Failure(t) => throw new IOException("async failure", t)
+          }
+        }
+
+        //order is essential - add to the queue before the CAS
+        pending.add(buffer)
+        if (scheduled.compareAndSet(false, true)) {
+          global.execute(background)
+        }
+      }
+
+      def run(): Unit = {
+        try {
+          while (!pending.isEmpty) {
+            val next = pending.poll()
+            if (next eq AsyncBufferedWriter.Flush) {
+              underlying.flush()
+            } else if (next eq AsyncBufferedWriter.Close) {
+              underlying.flush()
+              underlying.close()
+              asyncStatus.trySuccess(())
+            } else {
+              val array = next.array()
+              next.flip()
+              underlying.write(array, next.arrayOffset() + next.position(), next.limit())
+              reuseBuffer = next
+            }
+          }
+        } catch {
+          case t: Throwable =>
+            asyncStatus.tryFailure(t)
+            throw t
+        }
+        finally scheduled.set(false)
+
+        //we are not scheduled any more
+        //as a last check ensure that we didnt race with an addition to the queue
+        //order is essential - queue is checked before CAS
+        if ((!pending.isEmpty) && scheduled.compareAndSet(false, true)) {
+          global.execute(background)
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/compiler/src/dotty/tools/dotc/profile/Profiler.scala b/compiler/src/dotty/tools/dotc/profile/Profiler.scala
index a13c9d41b529..69a806215ddd 100644
--- a/compiler/src/dotty/tools/dotc/profile/Profiler.scala
+++ b/compiler/src/dotty/tools/dotc/profile/Profiler.scala
@@ -4,6 +4,7 @@ import scala.annotation.*
 import scala.language.unsafeNulls
 
 import java.io.{FileWriter, PrintWriter}
+import java.nio.file.Paths
 import java.lang.management.{ManagementFactory, GarbageCollectorMXBean, RuntimeMXBean, MemoryMXBean, ClassLoadingMXBean, CompilationMXBean}
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicInteger
@@ -12,8 +13,15 @@ import javax.management.{Notification, NotificationEmitter, NotificationListener
 
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.Contexts.*
+import dotty.tools.dotc.CompilationUnit
+import dotty.tools.dotc.core.Types.Type
+import dotty.tools.dotc.core.Symbols.{Symbol, NoSymbol}
+import dotty.tools.dotc.core.Flags
+import dotty.tools.backend.jvm.DottyBackendInterface.symExtensions
 import dotty.tools.io.AbstractFile
 import annotation.internal.sharable
+import dotty.tools.dotc.core.Periods.InitialRunId
+import scala.collection.mutable.UnrolledBuffer
 
 object Profiler {
   def apply()(using Context): Profiler =
@@ -25,14 +33,19 @@ object Profiler {
       new RealProfiler(reporter)
     }
 
-  private[profile] val emptySnap: ProfileSnap = ProfileSnap(0, "", 0, 0, 0, 0, 0, 0)
+  final def NoOp: Profiler = NoOpProfiler
+
+  private[profile] val emptySnap: ProfileSnap = ProfileSnap(0, "", 0, 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 GcEventData(pool:String, reportTimeNs: Long, gcStartMillis:Long, gcEndMillis:Long, durationMillis: Long, name:String, action:String, cause:String, threads:Long){
+  val endNanos = System.nanoTime()
+}
 
 case class ProfileSnap(threadId: Long, threadName: String, snapTimeNanos : Long,
                        idleTimeNanos:Long, cpuTimeNanos: Long, userTimeNanos: Long,
-                       allocatedBytes:Long, heapBytes:Long) {
+                       allocatedBytes:Long, heapBytes:Long,
+                       totalClassesLoaded: Long, totalJITCompilationTime: Long) {
   def updateHeap(heapBytes:Long): ProfileSnap =
     copy(heapBytes = heapBytes)
 }
@@ -66,22 +79,63 @@ case class ProfileRange(start: ProfileSnap, end:ProfileSnap, phase:Phase, purpos
   def retainedHeapMB: Double = toMegaBytes(end.heapBytes - start.heapBytes)
 }
 
+private opaque type TracedEventId <: String = String
+private object TracedEventId:
+  def apply(stringValue: String): TracedEventId = stringValue
+  final val Empty: TracedEventId = ""
+
 sealed trait Profiler {
 
   def finished(): Unit
 
-  def beforePhase(phase: Phase): ProfileSnap
-
-  def afterPhase(phase: Phase, profileBefore: ProfileSnap): Unit
+  inline def onPhase[T](phase: Phase)(inline body: T): T =
+    val (event, snapshot) = beforePhase(phase)
+    try body
+    finally afterPhase(event, phase, snapshot)
+  protected final val EmptyPhaseEvent = (TracedEventId.Empty, Profiler.emptySnap)
+  protected def beforePhase(phase: Phase): (TracedEventId, ProfileSnap) = EmptyPhaseEvent
+  protected def afterPhase(event: TracedEventId, phase: Phase, profileBefore: ProfileSnap): Unit = ()
+
+  inline def onUnit[T](phase: Phase, unit: CompilationUnit)(inline body: T): T =
+    val event = beforeUnit(phase, unit)
+    try body
+    finally afterUnit(event)
+  protected def beforeUnit(phase: Phase, unit: CompilationUnit): TracedEventId = TracedEventId.Empty
+  protected def afterUnit(event: TracedEventId): Unit = ()
+
+  inline def onTypedDef[T](sym: Symbol)(inline body: T): T =
+    val event = beforeTypedDef(sym)
+    try body
+    finally afterTypedDef(event)
+   protected def beforeTypedDef(sym: Symbol): TracedEventId = TracedEventId.Empty
+   protected def afterTypedDef(token: TracedEventId): Unit = ()
+
+  inline def onImplicitSearch[T](pt: Type)(inline body: T): T =
+    val event = beforeImplicitSearch(pt)
+    try body
+    finally afterImplicitSearch(event)
+  protected def beforeImplicitSearch(pt: Type): TracedEventId  = TracedEventId.Empty
+  protected def afterImplicitSearch(event: TracedEventId): Unit = ()
+
+  inline def onMacroSplice[T](macroSym: Symbol)(inline body: T): T =
+    val event = beforeMacroSplice(macroSym)
+    try body
+    finally afterMacroSplice(event)
+  protected def beforeMacroSplice(macroSym: Symbol): TracedEventId = TracedEventId.Empty
+  protected def afterMacroSplice(event: TracedEventId): Unit = ()
+
+  inline def onCompletion[T](root: Symbol, associatedFile: => AbstractFile)(inline body: T): T =
+    val (event, completionName) = beforeCompletion(root, associatedFile)
+    try body
+    finally afterCompletion(event, completionName)
+  protected final val EmptyCompletionEvent = (TracedEventId.Empty, "")
+  protected def beforeCompletion(root: Symbol, associatedFile: => AbstractFile): (TracedEventId, String) = EmptyCompletionEvent
+  protected def afterCompletion(event: TracedEventId, completionName: String): 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
@@ -92,17 +146,6 @@ private [profile] object RealProfiler {
   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 = {
@@ -117,13 +160,47 @@ private [profile] class RealProfiler(reporter : ProfileReporter)(using Context)
       cpuTimeNanos = threadMx.getCurrentThreadCpuTime,
       userTimeNanos = threadMx.getCurrentThreadUserTime,
       allocatedBytes = threadMx.getThreadAllocatedBytes(Thread.currentThread().getId),
-      heapBytes = readHeapUsage()
+      heapBytes = readHeapUsage(),
+      totalClassesLoaded = classLoaderMx.getTotalLoadedClassCount,
+      totalJITCompilationTime = compileMx.getTotalCompilationTime
     )
   }
   private def readHeapUsage() = RealProfiler.memoryMx.getHeapMemoryUsage.getUsed
+}
+
+private [profile] class RealProfiler(reporter : ProfileReporter)(using Context) extends Profiler with NotificationListener {
+  val id: Int = RealProfiler.idGen.incrementAndGet()
+  private val mainThread = Thread.currentThread()
+  private val gcEvents = UnrolledBuffer[GcEventData]()
+  private var nextAfterUnitSnap: Long = System.nanoTime()
+
+  private final val GcThreadId = "GC"
+
+  enum Category:
+    def name: String = this.toString().toLowerCase()
+    case Run, Phase, File, TypeCheck, Implicit, Macro, Completion
+  private [profile] val chromeTrace =
+    if ctx.settings.YprofileTrace.isDefault
+    then null
+    else
+      val filename = ctx.settings.YprofileTrace.value
+      // Compilation units requiring multi-stage compilation (macros) would create a new profiler instances
+      // We need to store the traces in the seperate file to prevent overriding its content.
+      // Alternatives: sharing ChromeTrace instance between all runs / manual concatation after all runs are done
+      // FIXME: The first assigned runId is equal to 2 instead of 1 (InitialRunId).
+      // Fix me when bug described in Compiler.runId is resolved by removing +/- 1 adjustments
+      val suffix = if ctx.runId > InitialRunId + 1 then s".${ctx.runId - 1}" else ""
+      ChromeTrace(Paths.get(s"$filename$suffix"))
+
+  private val compilerRunEvent: TracedEventId = traceDurationStart(Category.Run, s"scalac-$id")
+
+  def completeBackground(threadRange: ProfileRange): Unit =
+    reporter.reportBackground(this, threadRange)
+
+  def outDir: AbstractFile = ctx.settings.outputDir.value
 
   @nowarn
-  private def doGC: Unit = {
+  private def doGC(): Unit = {
     System.gc()
     System.runFinalization()
   }
@@ -142,6 +219,15 @@ private [profile] class RealProfiler(reporter : ProfileReporter)(using Context)
       case gc =>
     }
     reporter.close(this)
+    if chromeTrace != null then
+      traceDurationEnd(Category.Run, compilerRunEvent)
+      for gcEvent <- gcEvents
+      do {
+        val durationNanos = TimeUnit.MILLISECONDS.toNanos(gcEvent.durationMillis)
+        val startNanos = gcEvent.endNanos - durationNanos
+        chromeTrace.traceDurationEvent(gcEvent.name, startNanos, durationNanos, tid = GcThreadId)
+      }
+      chromeTrace.close()
   }
 
 
@@ -150,10 +236,7 @@ private [profile] class RealProfiler(reporter : ProfileReporter)(using Context)
     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
@@ -164,49 +247,127 @@ private [profile] class RealProfiler(reporter : ProfileReporter)(using Context)
         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))
+        val gcEvent = GcEventData("", reportNs, startTime, endTime, duration, name, action, cause, threads)
+        synchronized { gcEvents += gcEvent }
+        reporter.reportGc(gcEvent)
     }
   }
 
-  override def afterPhase(phase: Phase, snapBefore: ProfileSnap): Unit = {
+  override def afterPhase(event: TracedEventId, phase: Phase, snapBefore: ProfileSnap): Unit = {
     assert(mainThread eq Thread.currentThread())
-    val initialSnap = snapThread(0)
+    val initialSnap = RealProfiler.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())
+      doGC()
+      initialSnap.updateHeap(RealProfiler.readHeapUsage())
     }
     else initialSnap
-
+    traceDurationEnd(Category.Phase, event)
+    traceThreadSnapshotCounters()
     reporter.reportForeground(this, ProfileRange(snapBefore, finalSnap, phase, "", 0, Thread.currentThread))
   }
 
-  override def beforePhase(phase: Phase): ProfileSnap = {
+  override def beforePhase(phase: Phase): (TracedEventId, ProfileSnap) = {
     assert(mainThread eq Thread.currentThread())
+    traceThreadSnapshotCounters()
+    val eventId = traceDurationStart(Category.Phase, phase.phaseName)
     if (ctx.settings.YprofileRunGcBetweenPhases.value.contains(phase.toString))
-      doGC
+      doGC()
     if (ctx.settings.YprofileExternalTool.value.contains(phase.toString)) {
       println("Profile hook start")
       ExternalToolHook.before()
     }
-    snapThread(0)
+    (eventId, RealProfiler.snapThread(0))
+  }
+
+  override def beforeUnit(phase: Phase, unit: CompilationUnit): TracedEventId = {
+    assert(mainThread eq Thread.currentThread())
+    if chromeTrace != null then
+      traceThreadSnapshotCounters()
+      traceDurationStart(Category.File, unit.source.name)
+    else TracedEventId.Empty
+  }
+
+  override def afterUnit(event: TracedEventId): Unit = {
+    assert(mainThread eq Thread.currentThread())
+    if chromeTrace != null then
+      traceDurationEnd(Category.File, event)
+      traceThreadSnapshotCounters()
   }
-}
 
+  private def traceThreadSnapshotCounters(initialSnap: => ProfileSnap = RealProfiler.snapThread(0)) =
+    if chromeTrace != null && System.nanoTime() > nextAfterUnitSnap then {
+      val snap = initialSnap
+      chromeTrace.traceCounterEvent("allocBytes", "allocBytes", snap.allocatedBytes, processWide = false)
+      chromeTrace.traceCounterEvent("heapBytes", "heapBytes", snap.heapBytes, processWide = true)
+      chromeTrace.traceCounterEvent("classesLoaded", "classesLoaded", snap.totalClassesLoaded, processWide = true)
+      chromeTrace.traceCounterEvent("jitCompilationTime", "jitCompilationTime", snap.totalJITCompilationTime, processWide = true)
+      chromeTrace.traceCounterEvent("userTime", "userTime", snap.userTimeNanos, processWide = false)
+      chromeTrace.traceCounterEvent("cpuTime", "cpuTime", snap.cpuTimeNanos, processWide = false)
+      chromeTrace.traceCounterEvent("idleTime", "idleTime", snap.idleTimeNanos, processWide = false)
+      nextAfterUnitSnap = System.nanoTime() + 10 * 1000 * 1000
+    }
 
-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")
+  override def beforeTypedDef(sym: Symbol): TracedEventId = traceDurationStart(Category.TypeCheck, symbolName(sym))
+  override def afterTypedDef(event: TracedEventId): Unit = traceDurationEnd(Category.TypeCheck, event)
+
+  override def beforeImplicitSearch(pt: Type): TracedEventId = traceDurationStart(Category.Implicit, s"?[${symbolName(pt.typeSymbol)}]", colour = "yellow")
+  override def afterImplicitSearch(event: TracedEventId): Unit = traceDurationEnd(Category.Implicit, event, colour = "yellow")
+
+  override def beforeMacroSplice(macroSym: Symbol): TracedEventId = traceDurationStart(Category.Macro, s"«${symbolName(macroSym)}»", colour = "olive")
+  override def afterMacroSplice(event: TracedEventId): Unit = traceDurationEnd(Category.Macro, event, colour = "olive")
+
+  override def beforeCompletion(root: Symbol, associatedFile: => AbstractFile): (TracedEventId, String) =
+    if chromeTrace == null
+    then EmptyCompletionEvent
+    else
+      val completionName = this.completionName(root, associatedFile)
+      val event = TracedEventId(associatedFile.name)
+      chromeTrace.traceDurationEventStart(Category.Completion.name, "↯", colour = "thread_state_sleeping")
+      chromeTrace.traceDurationEventStart(Category.File.name, event)
+      chromeTrace.traceDurationEventStart(Category.Completion.name, completionName)
+      (event, completionName)
+
+  override def afterCompletion(event: TracedEventId, completionName: String): Unit =
+    if chromeTrace != null
+    then
+      chromeTrace.traceDurationEventEnd(Category.Completion.name, completionName)
+      chromeTrace.traceDurationEventEnd(Category.File.name, event)
+      chromeTrace.traceDurationEventEnd(Category.Completion.name, "↯", colour = "thread_state_sleeping")
+
+  private inline def traceDurationStart(category: Category, inline eventName: String, colour: String = ""): TracedEventId =
+    if chromeTrace == null
+    then TracedEventId.Empty
+    else
+      val event = TracedEventId(eventName)
+      chromeTrace.traceDurationEventStart(category.name, event, colour)
+      event
+
+  private inline def traceDurationEnd(category: Category, event: TracedEventId, colour: String = ""): Unit =
+    if chromeTrace != null then
+      chromeTrace.traceDurationEventEnd(category.name, event, colour)
+
+  private def symbolName(sym: Symbol): String = s"${sym.showKind} ${sym.showName}"
+  private def completionName(root: Symbol, associatedFile: AbstractFile): String =
+    def isTopLevel = root.owner != NoSymbol && root.owner.is(Flags.Package)
+    if root.is(Flags.Package) || isTopLevel
+    then root.javaBinaryName
+    else
+      val enclosing = root.enclosingClass
+      s"${enclosing.javaBinaryName}::${root.name}"
 }
 
+enum EventType(name: String):
+  // main thread with other tasks
+  case MAIN extends EventType("main")
+  // other task ( background thread)
+  case BACKGROUND extends EventType("background")
+  // total for compile
+  case GC extends EventType("GC")
+
 sealed trait ProfileReporter {
   def reportBackground(profiler: RealProfiler, threadRange: ProfileRange): Unit
   def reportForeground(profiler: RealProfiler, threadRange: ProfileRange): Unit
@@ -259,9 +420,8 @@ class StreamProfileReporter(out:PrintWriter) extends ProfileReporter {
     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
+    out.flush()
+    out.close()
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/profile/ThreadPoolFactory.scala b/compiler/src/dotty/tools/dotc/profile/ThreadPoolFactory.scala
index e3ea69d9be06..1a81153b9b08 100644
--- a/compiler/src/dotty/tools/dotc/profile/ThreadPoolFactory.scala
+++ b/compiler/src/dotty/tools/dotc/profile/ThreadPoolFactory.scala
@@ -94,9 +94,9 @@ object ThreadPoolFactory {
       val data = new ThreadProfileData
       localData.set(data)
 
-      val profileStart = profiler.snapThread(0)
+      val profileStart = RealProfiler.snapThread(0)
       try worker.run finally {
-        val snap = profiler.snapThread(data.idleNs)
+        val snap = RealProfiler.snapThread(data.idleNs)
         val threadRange = ProfileRange(profileStart, snap, phase, shortId, data.taskCount, Thread.currentThread())
         profiler.completeBackground(threadRange)
       }
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
index e42f997e7265..b5386d5bd1df 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -47,13 +47,14 @@ object Splicer {
   def splice(tree: Tree, splicePos: SrcPos, spliceExpansionPos: SrcPos, classLoader: ClassLoader)(using Context): Tree = tree match {
     case Quote(quotedTree, Nil) => quotedTree
     case _ =>
-      val macroOwner = newSymbol(ctx.owner, nme.MACROkw, Macro | Synthetic, defn.AnyType, coord = tree.span)
+      val owner = ctx.owner
+      val macroOwner = newSymbol(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 {
+          try ctx.profiler.onMacroSplice(owner){
             val interpreter = new SpliceInterpreter(splicePos, classLoader)
 
             // Some parts of the macro are evaluated during the unpickling performed in quotedExprToTree
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index c42b196b8dfb..0727c83d8469 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -1082,7 +1082,7 @@ trait Implicits:
    *                         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 =
+  def inferImplicit(pt: Type, argument: Tree, span: Span)(using Context): SearchResult = ctx.profiler.onImplicitSearch(pt):
     trace(s"search implicit ${pt.show}, arg = ${argument.show}: ${argument.tpe.show}", implicits, show = true) {
       record("inferImplicit")
       assert(ctx.phase.allowsImplicitSearch,
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 23855455e67b..3810bc66841e 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2823,7 +2823,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       case _ =>
         typed(rhs)
 
-  def typedValDef(vdef: untpd.ValDef, sym: Symbol)(using Context): Tree = {
+  def typedValDef(vdef: untpd.ValDef, sym: Symbol)(using Context): Tree = ctx.profiler.onTypedDef(sym) {
     val ValDef(name, tpt, _) = vdef
     checkNonRootName(vdef.name, vdef.nameSpan)
     completeAnnotations(vdef, sym)
@@ -2851,7 +2851,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     sym.owner.info.decls.openForMutations.unlink(sym)
     EmptyTree
 
-  def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(using Context): Tree = if !sym.info.exists then retractDefDef(sym) else {
+  def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(using Context): Tree = if !sym.info.exists then retractDefDef(sym) else ctx.profiler.onTypedDef(sym) {
 
     // TODO: - Remove this when `scala.language.experimental.erasedDefinitions` is no longer experimental.
     //       - Modify signature to `erased def erasedValue[T]: T`
@@ -2963,7 +2963,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     if !sym.is(Module) && !sym.isConstructor && sym.info.finalResultType.isErasedClass then
       sym.setFlag(Erased)
 
-  def typedTypeDef(tdef: untpd.TypeDef, sym: Symbol)(using Context): Tree = {
+  def typedTypeDef(tdef: untpd.TypeDef, sym: Symbol)(using Context): Tree = ctx.profiler.onTypedDef(sym) {
     val TypeDef(name, rhs) = tdef
     completeAnnotations(tdef, sym)
     val rhs1 = tdef.rhs match
@@ -2977,7 +2977,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     assignType(cpy.TypeDef(tdef)(name, rhs1), sym)
   }
 
-  def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(using Context): Tree = {
+  def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(using Context): Tree = ctx.profiler.onTypedDef(cls) {
     if (!cls.info.isInstanceOf[ClassInfo]) return EmptyTree.assertingErrorsReported
 
     val TypeDef(name, impl @ Template(constr, _, self, _)) = cdef: @unchecked
diff --git a/compiler/src/dotty/tools/dotc/typer/TyperPhase.scala b/compiler/src/dotty/tools/dotc/typer/TyperPhase.scala
index 0c63f5b4ecb1..264d0f170769 100644
--- a/compiler/src/dotty/tools/dotc/typer/TyperPhase.scala
+++ b/compiler/src/dotty/tools/dotc/typer/TyperPhase.scala
@@ -43,7 +43,7 @@ class TyperPhase(addRootImports: Boolean = true) extends Phase {
   def typeCheck(using Context)(using subphase: SubPhase): Boolean = monitor(subphase.name) {
     val unit = ctx.compilationUnit
     try
-      if !unit.suspended then
+      if !unit.suspended then ctx.profiler.onUnit(ctx.phase, unit):
         unit.tpdTree = ctx.typer.typedExpr(unit.untpdTree)
         typr.println("typed: " + unit.source)
         record("retained untyped trees", unit.untpdTree.treeSize)
diff --git a/compiler/test/dotty/tools/dotc/profile/ChromeTraceTest.scala b/compiler/test/dotty/tools/dotc/profile/ChromeTraceTest.scala
new file mode 100644
index 000000000000..07dc53da1f83
--- /dev/null
+++ b/compiler/test/dotty/tools/dotc/profile/ChromeTraceTest.scala
@@ -0,0 +1,93 @@
+package dotty.tools.dotc.profile
+
+import java.io.*
+
+import org.junit.Assert.*
+import org.junit.*
+import java.nio.file.Files
+import java.nio.charset.StandardCharsets
+import java.util.concurrent.locks.LockSupport
+import scala.concurrent.duration.*
+
+class ChromeTraceTest:
+  private def testTraceOutputs(generator: ChromeTrace => Unit)(checkContent: PartialFunction[List[String], Unit]): Unit = {
+    val outfile = Files.createTempFile("trace-", ".json").nn
+    val tracer = new ChromeTrace(outfile)
+    try generator(tracer)
+    finally tracer.close()
+    val contentLines = scala.io.Source.fromFile(outfile.toFile().nn).getLines().toList
+    checkContent.applyOrElse(
+      contentLines,
+      content => fail(s"Invalid output lines: ${content.mkString(System.lineSeparator().nn)}")
+    )
+  }
+
+  @Test def traceCounterEvent(): Unit = testTraceOutputs{ tracer =>
+    tracer.traceCounterEvent("foo", "counter1", 42, processWide = true)
+    tracer.traceCounterEvent("bar", "counter2", 21, processWide = false)
+  }{
+    case """{"traceEvents":[""" ::
+        s"""{"cat":"scalac","name":"foo","ph":"C","tid":"${tid1}","pid":"${pid1}","ts":${ts1},"args":{"counter1":42}}""" ::
+        s""",{"cat":"scalac","name":"bar","ph":"C","tid":"${tid2}","pid":"${pid2}","ts":${ts2},"args":{"counter2":21}}""" ::
+           "]}" :: Nil =>
+      assertEquals(tid1, tid2)
+      assertTrue(tid1.toIntOption.isDefined)
+      assertNotEquals(pid1, pid2)
+      assertTrue(pid1.toIntOption.isDefined)
+      assertEquals(s"$pid1-$tid1", pid2)
+      assertTrue(ts1.toLong < ts2.toLong)
+  }
+
+  @Test def traceDurationEvent(): Unit = testTraceOutputs{ tracer =>
+    tracer.traceDurationEvent(name = "name1", startNanos = 1000L, durationNanos = 2500L,  tid = "this-thread")
+    tracer.traceDurationEvent(name = "name2", startNanos = 1000L, durationNanos = 5000L,  tid = "this-thread", pidSuffix = "pidSuffix")
+  }{
+    case """{"traceEvents":[""" ::
+        s"""{"cat":"scalac","name":"name1","ph":"X","tid":"this-thread","pid":"${pid1}","ts":1,"dur":2}""" ::
+        s""",{"cat":"scalac","name":"name2","ph":"X","tid":"this-thread","pid":"${pid2}","ts":1,"dur":5}""" ::
+           "]}" :: Nil =>
+      assertTrue(pid1.toIntOption.isDefined)
+      assertEquals(s"$pid1-pidSuffix", pid2)
+  }
+
+  @Test def traceDurationEvents(): Unit = {
+    val testStart = System.nanoTime()
+    testTraceOutputs{ tracer =>
+    tracer.traceDurationEventStart(cat = "test1", name = "event1")
+    LockSupport.parkNanos(2.millis.toNanos)
+    tracer.traceDurationEventStart(cat = "test2", name = "event2", colour = "RED", pidSuffix = "pid-suffix")
+    LockSupport.parkNanos(4.millis.toNanos)
+    tracer.traceDurationEventEnd(cat = "test2", name = "event2")
+    LockSupport.parkNanos(8.millis.toNanos)
+    tracer.traceDurationEventEnd(cat = "test1", name = "event1", colour = "RED", pidSuffix = "pid-suffix")
+  }{
+    case """{"traceEvents":[""" ::
+        s"""{"cat":"test1","name":"event1","ph":"B","pid":"${pid1}","tid":"${tid1}","ts":${ts1}}""" ::
+        s""",{"cat":"test2","name":"event2","ph":"B","pid":"${pid2}","tid":"${tid2}","ts":${ts2},"cname":"RED"}""" ::
+        s""",{"cat":"test2","name":"event2","ph":"E","pid":"${pid3}","tid":"${tid3}","ts":${ts3}}""" ::
+        s""",{"cat":"test1","name":"event1","ph":"E","pid":"${pid4}","tid":"${tid4}","ts":${ts4},"cname":"RED"}""" ::
+           "]}" :: Nil =>
+      val traceEnd = System.nanoTime()
+      assertTrue(tid1.toIntOption.isDefined)
+      assertEquals(pid1, pid3)
+      assertTrue(pid1.endsWith(s"-$tid1"))
+      assertEquals(pid2, pid4)
+      assertTrue(pid2.endsWith("-pid-suffix"))
+      List(tid1, tid2, tid3).foreach: tid =>
+        assertEquals(tid4, tid)
+      List(pid1, pid2, pid3, pid4).foreach: pid =>
+        assertTrue(pid.takeWhile(_ != '-').toIntOption.isDefined)
+
+      List(ts1, ts2, ts3, ts4).map(_.toLong) match {
+        case all @ List(ts1, ts2, ts3, ts4) =>
+          all.foreach: ts =>
+            // Timestamps are presented using Epoch microsecondos
+            assertTrue(ts >= testStart / 1000)
+            assertTrue(ts <= traceEnd / 1000)
+          assertTrue(ts2 >= ts1 + 2.millis.toMicros)
+          assertTrue(ts3 >= ts2 + 4.millis.toMicros)
+          assertTrue(ts4 >= ts3 + 8.millis.toMicros)
+        case _ => fail("unreachable")
+      }
+  }
+}
diff --git a/compiler/test/dotty/tools/dotc/profile/FileUtilsTest.scala b/compiler/test/dotty/tools/dotc/profile/FileUtilsTest.scala
new file mode 100644
index 000000000000..3253cff52057
--- /dev/null
+++ b/compiler/test/dotty/tools/dotc/profile/FileUtilsTest.scala
@@ -0,0 +1,91 @@
+package dotty.tools.dotc.profile
+
+import java.io.*
+
+import org.junit.Assert.*
+import org.junit.*
+
+class FileUtilsTest {
+
+  @Test def writeIsSame(): Unit = {
+    val fileTest = File.createTempFile("FileUtilsTest", "t1").nn
+    val fileExpected = File.createTempFile("FileUtilsTest", "t2").nn
+
+    val sTest = FileUtils.newAsyncBufferedWriter(new FileWriter(fileTest), threadsafe = false)
+    val sExpected = new BufferedWriter(new FileWriter(fileExpected))
+
+    def writeBoth(s:String, asChars: Boolean) = {
+      if (asChars) {
+        sTest.write(s.toCharArray)
+        sExpected.write(s.toCharArray)
+      } else {
+        sTest.write(s)
+        sExpected.write(s)
+      }
+    }
+
+    for (i <- 1 to 2000) {
+      writeBoth(s"line $i text;", asChars = true)
+      writeBoth(s"line $i chars", asChars = false)
+      sTest.newLine()
+      sExpected.newLine()
+    }
+    sTest.close()
+    sExpected.close()
+
+    assertEquals(fileExpected.length(),fileTest.length())
+
+    val expIn = new BufferedReader(new FileReader(fileExpected))
+    val testIn = new BufferedReader(new FileReader(fileTest))
+
+    var exp = expIn.readLine()
+    while (exp ne null) {
+      val actual = testIn.readLine()
+      assertEquals(exp, actual)
+      exp = expIn.readLine()
+    }
+    expIn.close()
+    testIn.close()
+    fileTest.delete()
+    fileExpected.delete()
+  }
+
+  @Ignore
+  @Test def showPerformance(): Unit = {
+    //warmup
+    for (i <- 1 to 1000) {
+      writeIsSame()
+    }
+
+    val fileTest = File.createTempFile("FileUtilsTest", "t1").nn
+    val fileExpected = File.createTempFile("FileUtilsTest", "t2").nn
+
+    for (i <- 1 to 10) {
+      val sTest = FileUtils.newAsyncBufferedWriter(fileTest.toPath.nn)
+      val sExpected = new BufferedWriter(new FileWriter(fileExpected))
+
+      val t1 = System.nanoTime()
+      List.tabulate(10000) {i =>
+        sTest.write(s"line $i text;")
+        sTest.newLine()
+      }
+      val t2 = System.nanoTime()
+      sTest.close()
+      val t3 = System.nanoTime()
+      List.tabulate(10000) {i =>
+        sExpected.write(s"line $i text;")
+        sExpected.newLine()
+      }
+      val t4 = System.nanoTime()
+      sExpected.close()
+
+      println(s"async    took ${t2 - t1} ns")
+      println(s"buffered took ${t4 - t3} ns")
+
+      fileTest.delete()
+      fileExpected.delete()
+    }
+  }
+
+}
+
diff --git a/presentation-compiler/src/main/dotty/tools/pc/completions/CompletionProvider.scala b/presentation-compiler/src/main/dotty/tools/pc/completions/CompletionProvider.scala
index 5578fab412d1..adaeadb12978 100644
--- a/presentation-compiler/src/main/dotty/tools/pc/completions/CompletionProvider.scala
+++ b/presentation-compiler/src/main/dotty/tools/pc/completions/CompletionProvider.scala
@@ -21,6 +21,7 @@ import dotty.tools.dotc.interactive.Interactive
 import dotty.tools.dotc.interactive.Completion
 import dotty.tools.dotc.interactive.InteractiveDriver
 import dotty.tools.dotc.parsing.Tokens
+import dotty.tools.dotc.profile.Profiler
 import dotty.tools.dotc.util.SourceFile
 import dotty.tools.pc.AutoImports.AutoImportEdits
 import dotty.tools.pc.AutoImports.AutoImportsGenerator
@@ -75,7 +76,10 @@ class CompletionProvider(
     val pos = driver.sourcePosition(params)
     val (items, isIncomplete) = driver.compilationUnits.get(uri) match
       case Some(unit) =>
-        val newctx = ctx.fresh.setCompilationUnit(unit).withPhase(Phases.typerPhase(using ctx))
+        val newctx = ctx.fresh
+          .setCompilationUnit(unit)
+          .setProfiler(Profiler()(using ctx))
+          .withPhase(Phases.typerPhase(using ctx))
         val tpdPath0 = Interactive.pathTo(unit.tpdTree, pos.span)(using newctx)
         val adjustedPath = Interactive.resolveTypedOrUntypedPath(tpdPath0, pos)(using newctx)
 

From f7f51edb424b281f751a9a47ea2397d5cf5b0343 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Wed, 23 Oct 2024 10:46:09 +0200
Subject: [PATCH 062/306] Don't warn for deprecated Thread.getId() calls in
 `ChromeTrace` (#21831)

---
 compiler/src/dotty/tools/dotc/profile/ChromeTrace.scala | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/src/dotty/tools/dotc/profile/ChromeTrace.scala b/compiler/src/dotty/tools/dotc/profile/ChromeTrace.scala
index c33039f46398..4950f439640f 100644
--- a/compiler/src/dotty/tools/dotc/profile/ChromeTrace.scala
+++ b/compiler/src/dotty/tools/dotc/profile/ChromeTrace.scala
@@ -45,6 +45,7 @@ final class ChromeTrace(f: Path) extends Closeable {
   private val traceWriter = FileUtils.newAsyncBufferedWriter(f)
   private val context = mutable.Stack[JsonContext](TopContext)
   private val tidCache = new ThreadLocal[String]() {
+    @annotation.nowarn("cat=deprecation")
     override def initialValue(): String = "%05d".format(Thread.currentThread().getId())
   }
   objStart()

From aa9115dbfa25f18a8abb5d555be77fbb3dc3b8bc Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Wed, 23 Oct 2024 18:20:20 +0200
Subject: [PATCH 063/306] Fix typo in allTermArguments

---
 compiler/src/dotty/tools/dotc/ast/TreeInfo.scala | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index 23610a0fcfeb..09c855847fac 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -142,9 +142,9 @@ trait TreeInfo[T <: Untyped] { self: Trees.Instance[T] =>
 
   /** All term arguments of an application in a single flattened list */
   def allTermArguments(tree: Tree): List[Tree] = unsplice(tree) match {
-    case Apply(fn, args) => allArguments(fn) ::: args
-    case TypeApply(fn, args) => allArguments(fn)
-    case Block(_, expr) => allArguments(expr)
+    case Apply(fn, args) => allTermArguments(fn) ::: args
+    case TypeApply(fn, args) => allTermArguments(fn)
+    case Block(_, expr) => allTermArguments(expr)
     case _ => Nil
   }
 

From b00649a5a3ab914e999d7c4d7c08e5f23cd41a70 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 23 Oct 2024 17:40:15 +0100
Subject: [PATCH 064/306] Drop the extra Nothing/Null handling in
 SpaceEngine.signature

---
 .../tools/dotc/transform/patmat/Space.scala   | 29 ++++++-------------
 1 file changed, 9 insertions(+), 20 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index af37135e5196..a1b34c11a859 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -524,27 +524,16 @@ object SpaceEngine {
     val mt: MethodType = unapp.widen match {
       case mt: MethodType => mt
       case pt: PolyType   =>
-        if unappSym.is(Synthetic) then
-          val mt = pt.resultType.asInstanceOf[MethodType]
-          val unapplyArgType = mt.paramInfos.head
-          val targs = scrutineeTp.baseType(unapplyArgType.classSymbol) match
-            case AppliedType(_, targs) => targs
-            case _ =>
-              // Typically when the scrutinee is Null or Nothing (see i5067 and i5067b)
-              // For performance, do `variances(unapplyArgType)` but without using TypeVars
-              // so just find the variance, so we know if to min/max to the LB/UB or use a wildcard.
-              object accu extends TypeAccumulator[VarianceMap[TypeParamRef]]:
-                def apply(vmap: VarianceMap[TypeParamRef], tp: Type) = tp match
-                  case tp: TypeParamRef if tp.binder eq pt => vmap.recordLocalVariance(tp, variance)
-                  case _                                   => foldOver(vmap, tp)
-              val vs = accu(VarianceMap.empty[TypeParamRef], unapplyArgType)
-              pt.paramRefs.map: p =>
-                vs.computedVariance(p).uncheckedNN match
-                  case -1 => p.paramInfo.lo
-                  case 1  => p.paramInfo.hi
-                  case _  => WildcardType(p.paramInfo)
+        scrutineeTp match
+        case AppliedType(tycon, targs)
+            if unappSym.is(Synthetic)
+            && (pt.resultType.asInstanceOf[MethodType].paramInfos.head.typeConstructor eq tycon) =>
+          // Special case synthetic unapply/unapplySeq's
+          // Provided the shapes of the types match:
+          // the scrutinee type being unapplied and
+          // the unapply parameter type
           pt.instantiate(targs).asInstanceOf[MethodType]
-        else
+        case _ =>
           val locked = ctx.typerState.ownedVars
           val tvars = constrained(pt)
           val mt = pt.instantiate(tvars).asInstanceOf[MethodType]

From 15922f93c59dc0ae60ae1b26362962b0b5c04921 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 21 Aug 2024 16:06:44 +0100
Subject: [PATCH 065/306] Fix enclosingClass from returning refinement classes

Looking at how i20952 is compiled, the call

    ctx.owner.enclosingClass.derivesFrom(sym.owner)

in SuperAccessors (that I moved to ProtectedAccessors) accidentally
fails, because the refinement class returned as the enclosing class of
`val prog` doesn't derive from SuperClass.  But if the enclosing class
of `prog` returned is `trait Child` then no super accessor call is
necessary.
---
 .../tools/dotc/core/SymDenotations.scala      |  6 +++---
 .../dotc/transform/ProtectedAccessors.scala   |  5 ++++-
 .../tools/dotc/transform/SuperAccessors.scala |  2 +-
 tests/pos/i20952.scala                        | 20 +++++++++++++++++++
 4 files changed, 28 insertions(+), 5 deletions(-)
 create mode 100644 tests/pos/i20952.scala

diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index 906e74735097..f54b8a62fa25 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -1162,10 +1162,10 @@ object SymDenotations {
     final def enclosingClass(using Context): Symbol = {
       def enclClass(sym: Symbol, skip: Boolean): Symbol = {
         def newSkip = sym.is(JavaStaticTerm)
-        if (!sym.exists)
+        if !sym.exists then
           NoSymbol
-        else if (sym.isClass)
-          if (skip) enclClass(sym.owner, newSkip) else sym
+        else if sym.isClass then
+          if skip || sym.isRefinementClass then enclClass(sym.owner, newSkip) else sym
         else
           enclClass(sym.owner, skip || newSkip)
       }
diff --git a/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala b/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala
index 482da0edb82b..359ec701d164 100644
--- a/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala
@@ -44,7 +44,10 @@ object ProtectedAccessors {
   /** 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)
+    !needsAccessorIsSubclass(sym)
+
+  def needsAccessorIsSubclass(sym: Symbol)(using Context): Boolean =
+    ctx.owner.enclosingClass.derivesFrom(sym.owner)
 }
 
 class ProtectedAccessors extends MiniPhase {
diff --git a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
index ce2b8fa591d8..5a63235fc3c0 100644
--- a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
@@ -195,7 +195,7 @@ class SuperAccessors(thisPhase: DenotTransformer) {
          * Otherwise, we need to go through an accessor,
          * which the implementing class will provide an implementation for.
          */
-        if ctx.owner.enclosingClass.derivesFrom(sym.owner) then
+        if ProtectedAccessors.needsAccessorIsSubclass(sym) then
           if sym.is(JavaDefined) then
             report.error(em"${ctx.owner} accesses protected $sym inside a concrete trait method: use super.${sel.name} instead", sel.srcPos)
           sel
diff --git a/tests/pos/i20952.scala b/tests/pos/i20952.scala
new file mode 100644
index 000000000000..68344fdab672
--- /dev/null
+++ b/tests/pos/i20952.scala
@@ -0,0 +1,20 @@
+package object packer: // the super class needs to be in a different package
+  class SuperClass():
+    protected val problem: Any = ??? // needs to be protected
+
+class SuperClass():
+  protected val problem: Any = ??? // needs to be protected
+
+// type Target = SuperClass        // passes
+type Target = packer.SuperClass // error
+
+trait Child extends Target:
+
+  val aliased: problem.type = problem
+  type Alias = problem.type
+
+  val newProblem: Any {val prog: problem.type} = ???  // error
+  val newProblem2: Any {val prog: Alias} = ???         // passes
+  val newProblem3: Any {val prog: aliased.type} = ???  // passes
+
+class ChildImpl extends Target with Child // concrete implementation is needed

From 0cf41d07341a1dc27f8fe4a71b91641612375f90 Mon Sep 17 00:00:00 2001
From: HarrisL2 <harris.yh.lau@gmail.com>
Date: Fri, 20 Sep 2024 23:23:39 -0400
Subject: [PATCH 066/306] Improve warning for wildcard matching only null under
 explicit nulls (scala#21577)

Adds a more detailed warning message when a wildcard case is only reachable
by null under explict nulls flag.

Fixes scala#21577
---
 .../tools/dotc/transform/patmat/Space.scala   | 16 +++++++++----
 .../dotty/tools/dotc/CompilationTests.scala   |  5 ++++
 tests/explicit-nulls/warn/i21577.check        | 12 ++++++++++
 tests/explicit-nulls/warn/i21577.scala        | 24 +++++++++++++++++++
 4 files changed, 52 insertions(+), 5 deletions(-)
 create mode 100644 tests/explicit-nulls/warn/i21577.check
 create mode 100644 tests/explicit-nulls/warn/i21577.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 9fb3c00c67c4..deaf285c79cc 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -920,7 +920,7 @@ object SpaceEngine {
       then project(OrType(selTyp, ConstantType(Constant(null)), soft = false))
       else project(selTyp)
     )
-
+    
     var i        = 0
     val len      = cases.length
     var prevs    = List.empty[Space]
@@ -942,11 +942,17 @@ object SpaceEngine {
           report.warning(MatchCaseUnreachable(), pat.srcPos)
         if pat != EmptyTree // rethrow case of catch uses EmptyTree
             && !pat.symbol.isAllOf(SyntheticCase, butNot=Method) // ExpandSAMs default cases use SyntheticCase
-            && isSubspace(covered, prev)
+            && isSubspace(covered, Or(List(prev, Typ(defn.NullType)))) // for when Null is not subtype of AnyRef under explicit nulls
         then {
-          val nullOnly = isNullable && i == len - 1 && isWildcardArg(pat)
-          val msg = if nullOnly then MatchCaseOnlyNullWarning() else MatchCaseUnreachable()
-          report.warning(msg, pat.srcPos)
+          val nullOnly = 
+            (isNullable || (defn.NullType <:< selTyp)) 
+            && i == len - 1 
+            && isWildcardArg(pat)
+          if nullOnly then {
+            report.warning(MatchCaseOnlyNullWarning(), pat.srcPos)
+          } else if isSubspace(covered, prev) then {
+            report.warning(MatchCaseUnreachable(), pat.srcPos)
+          }
         }
         deferred = Nil
       }
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index d7ef7f6f6085..de00faa86406 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -213,6 +213,11 @@ class CompilationTests {
     )
   }.checkCompile()
 
+  @Test def explicitNullsWarn: Unit = {
+    implicit val testGroup: TestGroup = TestGroup("explicitNullsWarn")
+    compileFilesInDir("tests/explicit-nulls/warn", explicitNullsOptions)
+  }.checkWarnings()
+
   @Test def explicitNullsRun: Unit = {
     implicit val testGroup: TestGroup = TestGroup("explicitNullsRun")
     compileFilesInDir("tests/explicit-nulls/run", explicitNullsOptions)
diff --git a/tests/explicit-nulls/warn/i21577.check b/tests/explicit-nulls/warn/i21577.check
new file mode 100644
index 000000000000..944b2ccab3c9
--- /dev/null
+++ b/tests/explicit-nulls/warn/i21577.check
@@ -0,0 +1,12 @@
+-- [E121] Pattern Match Warning: tests/explicit-nulls/warn/i21577.scala:5:9 --------------------------------------------
+5 |    case _ => println(2) // warn
+  |         ^
+  |         Unreachable case except for null (if this is intentional, consider writing case null => instead).
+-- [E121] Pattern Match Warning: tests/explicit-nulls/warn/i21577.scala:12:11 ------------------------------------------
+12 |      case _ => println(2) // warn
+   |           ^
+   |           Unreachable case except for null (if this is intentional, consider writing case null => instead).
+-- [E121] Pattern Match Warning: tests/explicit-nulls/warn/i21577.scala:18:11 ------------------------------------------
+18 |      case _ => println(2) // warn
+   |           ^
+   |           Unreachable case except for null (if this is intentional, consider writing case null => instead).
diff --git a/tests/explicit-nulls/warn/i21577.scala b/tests/explicit-nulls/warn/i21577.scala
new file mode 100644
index 000000000000..d5da1403deea
--- /dev/null
+++ b/tests/explicit-nulls/warn/i21577.scala
@@ -0,0 +1,24 @@
+def f(s: String) =
+  val s2 = s.trim()
+  s2 match
+    case s3: String => println(1)
+    case _ => println(2) // warn
+
+
+def f2(s: String | Null) =
+  val s2 = s.nn.trim()
+    s2 match
+      case s3: String => println(1)
+      case _ => println(2) // warn
+
+def f3(s: String | Null) =
+  val s2 = s
+    s2 match
+      case s3: String => println(1)
+      case _ => println(2) // warn
+
+def f4(s: String | Int) =
+  val s2 = s
+    s2 match
+      case s3: String => println(1)
+      case _ => println(2)
\ No newline at end of file

From 4f775fab0f16a27d6be276dde0834cd286d8b506 Mon Sep 17 00:00:00 2001
From: HarrisL2 <harris.yh.lau@gmail.com>
Date: Thu, 17 Oct 2024 15:00:04 -0400
Subject: [PATCH 067/306] Implement change and add test cases

---
 .../tools/dotc/transform/patmat/Space.scala   | 82 ++++++++-----------
 .../pos/interop-constructor.scala             |  2 +-
 tests/explicit-nulls/warn/i21577.check        | 34 ++++++--
 tests/explicit-nulls/warn/i21577.scala        | 48 +++++++----
 tests/explicit-nulls/warn/interop.check       |  8 ++
 tests/explicit-nulls/warn/interop/J.java      |  6 ++
 tests/explicit-nulls/warn/interop/S.scala     | 10 +++
 7 files changed, 114 insertions(+), 76 deletions(-)
 create mode 100644 tests/explicit-nulls/warn/interop.check
 create mode 100644 tests/explicit-nulls/warn/interop/J.java
 create mode 100644 tests/explicit-nulls/warn/interop/S.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index deaf285c79cc..c7b304e6caf6 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -14,6 +14,7 @@ import typer.*, Applications.*, Inferencing.*, ProtoTypes.*
 import util.*
 
 import scala.annotation.internal.sharable
+import scala.annotation.tailrec
 import scala.collection.mutable
 
 import SpaceEngine.*
@@ -696,7 +697,7 @@ object SpaceEngine {
           else NoType
         }.filter(_.exists)
         parts
-
+      case tp: FlexibleType => List(tp.underlying, ConstantType(Constant(null)))
       case _ => ListOfNoType
     end rec
 
@@ -876,6 +877,7 @@ object SpaceEngine {
     case tp: SingletonType                          => toUnderlying(tp.underlying)
     case tp: ExprType                               => toUnderlying(tp.resultType)
     case AnnotatedType(tp, annot)                   => AnnotatedType(toUnderlying(tp), annot)
+    case tp: FlexibleType                           => tp.derivedFlexibleType(toUnderlying(tp.underlying))
     case _                                          => tp
   })
 
@@ -910,58 +912,40 @@ object SpaceEngine {
     && !sel.tpe.widen.isRef(defn.QuotedExprClass)
     && !sel.tpe.widen.isRef(defn.QuotedTypeClass)
 
-  def checkReachability(m: Match)(using Context): Unit = trace(i"checkReachability($m)") {
-    val cases = m.cases.toIndexedSeq
-
+  def checkReachability(m: Match)(using Context): Unit = trace(i"checkReachability($m)"):
     val selTyp = toUnderlying(m.selector.tpe).dealias
-
-    val isNullable = selTyp.classSymbol.isNullableClass
-    val targetSpace = trace(i"targetSpace($selTyp)")(if isNullable
+    val isNullable = selTyp.isInstanceOf[FlexibleType] || selTyp.classSymbol.isNullableClass
+    val targetSpace = trace(i"targetSpace($selTyp)"):
+      if isNullable && !ctx.mode.is(Mode.SafeNulls)
       then project(OrType(selTyp, ConstantType(Constant(null)), soft = false))
       else project(selTyp)
-    )
-    
-    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)
 
-      val curr = trace(i"project($pat)")(project(pat))
-
-      val covered = trace("covered")(simplify(intersect(curr, targetSpace)))
-
-      val prev = trace("prev")(simplify(Or(prevs)))
-
-      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
-            && !pat.symbol.isAllOf(SyntheticCase, butNot=Method) // ExpandSAMs default cases use SyntheticCase
-            && isSubspace(covered, Or(List(prev, Typ(defn.NullType)))) // for when Null is not subtype of AnyRef under explicit nulls
-        then {
-          val nullOnly = 
-            (isNullable || (defn.NullType <:< selTyp)) 
-            && i == len - 1 
-            && isWildcardArg(pat)
-          if nullOnly then {
-            report.warning(MatchCaseOnlyNullWarning(), pat.srcPos)
-          } else if isSubspace(covered, prev) then {
-            report.warning(MatchCaseUnreachable(), 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
-    }
-  }
+    @tailrec def recur(cases: List[CaseDef], prevs: List[Space], deferred: List[Tree]): Unit =
+      cases match
+        case Nil =>
+        case CaseDef(pat, guard, _) :: rest =>
+          val curr = trace(i"project($pat)")(project(pat))
+          val covered = trace("covered")(simplify(intersect(curr, targetSpace)))
+          val prev = trace("prev")(simplify(Or(prevs)))
+          if prev == Empty && covered == Empty then // defer until a case is reachable
+            recur(rest, prevs, pat :: deferred)
+          else
+            for pat <- deferred.reverseIterator
+            do report.warning(MatchCaseUnreachable(), pat.srcPos)
+
+            if pat != EmptyTree // rethrow case of catch uses EmptyTree
+                && !pat.symbol.isAllOf(SyntheticCase, butNot=Method) // ExpandSAMs default cases use SyntheticCase
+                && isSubspace(covered, prev)
+            then
+              val nullOnly = isNullable && rest.isEmpty && isWildcardArg(pat)
+              val msg = if nullOnly then MatchCaseOnlyNullWarning() else MatchCaseUnreachable()
+              report.warning(msg, pat.srcPos)
+
+            val newPrev = if guard.isEmpty then covered :: prevs else prevs
+            recur(rest, newPrev, Nil)
+
+    recur(m.cases, Nil, Nil)
+  end checkReachability
 
   def checkMatch(m: Match)(using Context): Unit =
     if exhaustivityCheckable(m.selector) then checkExhaustivity(m)
diff --git a/tests/explicit-nulls/pos/interop-constructor.scala b/tests/explicit-nulls/pos/interop-constructor.scala
index f222d24b0919..4ebfaa752b3a 100644
--- a/tests/explicit-nulls/pos/interop-constructor.scala
+++ b/tests/explicit-nulls/pos/interop-constructor.scala
@@ -1,4 +1,4 @@
-// Test that constructors have a non-nullab.e return type.
+// Test that constructors have a non-nullable return type.
 
 class Foo {
   val x: java.lang.String = new java.lang.String()
diff --git a/tests/explicit-nulls/warn/i21577.check b/tests/explicit-nulls/warn/i21577.check
index 944b2ccab3c9..acedd7a9c713 100644
--- a/tests/explicit-nulls/warn/i21577.check
+++ b/tests/explicit-nulls/warn/i21577.check
@@ -1,12 +1,28 @@
 -- [E121] Pattern Match Warning: tests/explicit-nulls/warn/i21577.scala:5:9 --------------------------------------------
-5 |    case _ => println(2) // warn
+5 |    case _ => // warn
   |         ^
   |         Unreachable case except for null (if this is intentional, consider writing case null => instead).
--- [E121] Pattern Match Warning: tests/explicit-nulls/warn/i21577.scala:12:11 ------------------------------------------
-12 |      case _ => println(2) // warn
-   |           ^
-   |           Unreachable case except for null (if this is intentional, consider writing case null => instead).
--- [E121] Pattern Match Warning: tests/explicit-nulls/warn/i21577.scala:18:11 ------------------------------------------
-18 |      case _ => println(2) // warn
-   |           ^
-   |           Unreachable case except for null (if this is intentional, consider writing case null => instead).
+-- [E121] Pattern Match Warning: tests/explicit-nulls/warn/i21577.scala:12:9 -------------------------------------------
+12 |    case _ => // warn
+   |         ^
+   |         Unreachable case except for null (if this is intentional, consider writing case null => instead).
+-- [E030] Match case Unreachable Warning: tests/explicit-nulls/warn/i21577.scala:20:7 ----------------------------------
+20 |  case _ => // warn
+   |       ^
+   |       Unreachable case
+-- [E029] Pattern Match Exhaustivity Warning: tests/explicit-nulls/warn/i21577.scala:29:27 -----------------------------
+29 |def f7(s: String | Null) = s match // warn
+   |                           ^
+   |                           match may not be exhaustive.
+   |
+   |                           It would fail on pattern case: _: Null
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E029] Pattern Match Exhaustivity Warning: tests/explicit-nulls/warn/i21577.scala:36:33 -----------------------------
+36 |def f9(s: String | Int | Null) = s match // warn
+   |                                 ^
+   |                                 match may not be exhaustive.
+   |
+   |                                 It would fail on pattern case: _: Int
+   |
+   | longer explanation available when compiling with `-explain`
diff --git a/tests/explicit-nulls/warn/i21577.scala b/tests/explicit-nulls/warn/i21577.scala
index d5da1403deea..67da6068f22c 100644
--- a/tests/explicit-nulls/warn/i21577.scala
+++ b/tests/explicit-nulls/warn/i21577.scala
@@ -1,24 +1,38 @@
 def f(s: String) =
   val s2 = s.trim()
   s2 match
-    case s3: String => println(1)
-    case _ => println(2) // warn
+    case s3: String =>
+    case _ => // warn
 
 
 def f2(s: String | Null) =
   val s2 = s.nn.trim()
-    s2 match
-      case s3: String => println(1)
-      case _ => println(2) // warn
-
-def f3(s: String | Null) =
-  val s2 = s
-    s2 match
-      case s3: String => println(1)
-      case _ => println(2) // warn
-
-def f4(s: String | Int) =
-  val s2 = s
-    s2 match
-      case s3: String => println(1)
-      case _ => println(2)
\ No newline at end of file
+  s2 match
+    case s3: String =>
+    case _ => // warn
+
+def f3(s: String | Null) = s match
+  case s2: String =>
+  case _ =>
+
+def f5(s: String) = s match
+  case _: String =>
+  case _ => // warn
+
+def f6(s: String) = s.trim() match
+  case _: String =>
+  case null =>
+
+def f61(s: String) = s.trim() match
+  case _: String =>
+
+def f7(s: String | Null) = s match // warn
+  case _: String =>
+
+def f8(s: String | Null) = s match
+  case _: String =>
+  case null =>
+
+def f9(s: String | Int | Null) = s match // warn
+  case _: String =>
+  case null =>
\ No newline at end of file
diff --git a/tests/explicit-nulls/warn/interop.check b/tests/explicit-nulls/warn/interop.check
new file mode 100644
index 000000000000..0afc1dc0a3cb
--- /dev/null
+++ b/tests/explicit-nulls/warn/interop.check
@@ -0,0 +1,8 @@
+-- [E121] Pattern Match Warning: tests/explicit-nulls/warn/interop/S.scala:8:11 ----------------------------------------
+8 |      case _ => // warn
+  |           ^
+  |           Unreachable case except for null (if this is intentional, consider writing case null => instead).
+-- [E121] Pattern Match Warning: tests/explicit-nulls/warn/interop/S.scala:9:9 -----------------------------------------
+9 |    case _ => println(2) // warn
+  |         ^
+  |         Unreachable case except for null (if this is intentional, consider writing case null => instead).
diff --git a/tests/explicit-nulls/warn/interop/J.java b/tests/explicit-nulls/warn/interop/J.java
new file mode 100644
index 000000000000..f81cf685b9a9
--- /dev/null
+++ b/tests/explicit-nulls/warn/interop/J.java
@@ -0,0 +1,6 @@
+import java.util.ArrayList;
+
+class J {
+	ArrayList<ArrayList<String>> foo(String x) { return null; }
+	static String fooStatic(String x) { return null; }
+}
diff --git a/tests/explicit-nulls/warn/interop/S.scala b/tests/explicit-nulls/warn/interop/S.scala
new file mode 100644
index 000000000000..57beebe4eb76
--- /dev/null
+++ b/tests/explicit-nulls/warn/interop/S.scala
@@ -0,0 +1,10 @@
+import java.util.ArrayList
+def f() =
+  val j = new J()
+  val s2 = j.foo(null)
+  s2 match
+    case s3: ArrayList[ArrayList[String]] => s3.get(0) match
+      case _: ArrayList[_] =>
+      case _ => // warn
+    case _ => println(2) // warn
+

From 641b67a0ce50ae52cc401ea3855bd4bac9ab4622 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Wed, 23 Oct 2024 23:22:44 +0200
Subject: [PATCH 068/306] Add minimal set of tests for runner installed from
 .msi file (#21835)

Add minimal set of tests to check installation of Scala runner from .msi
file.
---
 .github/workflows/ci.yaml      | 10 ++++-
 .github/workflows/test-msi.yml | 77 ++++++++++++++++++++++++++++++++++
 2 files changed, 86 insertions(+), 1 deletion(-)
 create mode 100644 .github/workflows/test-msi.yml

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 91086858c514..ffa7e515b926 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -1119,7 +1119,15 @@ jobs:
   build-msi-package:
     uses: ./.github/workflows/build-msi.yml
     if  : github.event_name == 'pull_request' && contains(github.event.pull_request.body, '[test_msi]')
-    # TODO: ADD A JOB THAT DEPENDS ON THIS TO TEST THE MSI
+
+  test-msi-package:
+    uses: ./.github/workflows/test-msi.yml
+    needs: [build-msi-package]
+    with:
+      # Ensure that version starts with prefix 3.
+      # In the future it can be adapted to compare with with git tag or version set in the build.s 
+      version: "3."
+      java-version: 8
 
   build-sdk-package:
     uses: ./.github/workflows/build-sdk.yml
diff --git a/.github/workflows/test-msi.yml b/.github/workflows/test-msi.yml
new file mode 100644
index 000000000000..1299c3d55061
--- /dev/null
+++ b/.github/workflows/test-msi.yml
@@ -0,0 +1,77 @@
+###################################################################################################
+###                  THIS IS A REUSABLE WORKFLOW TO TEST SCALA WITH MSI RUNNER                  ###
+### HOW TO USE:                                                                                 ###
+###  Provide optional `version` to test if installed binaries are installed with                ###
+###  correct Scala version.                                                                     ###
+### NOTE: Requires `scala.msi` artifact uploaded within the same run                            ###
+###                                                                                             ###
+###################################################################################################
+
+name: Test 'scala' MSI Package
+run-name: Test 'scala' (${{ inputs.version }}) MSI Package
+
+on:
+  workflow_call:
+    inputs:
+      version:
+        required: true
+        type: string
+      java-version:
+        required: true
+        type    : string
+
+jobs:
+  test:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: ${{ inputs.java-version }}
+      - name: Download MSI artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: scala.msi
+          path: .
+
+      # Run the MSI installer
+      # During normal installation msiexec would modify the PATH automatically. 
+      # However, it seems not to work in GH Actions. Append the PATH manually instead.
+      - name: Install Scala Runner
+        shell: pwsh
+        run: |
+          Start-Process 'msiexec.exe' -ArgumentList '/I "scala.msi" /L*V "install.log" /qb' -Wait
+          Get-Content 'install.log'
+          Add-Content $env:GITHUB_PATH "C:\Program Files (x86)\scala\bin"
+
+      # Run tests to ensure the Scala Runner was installed and works
+      - name: Test Scala Runner
+        shell: pwsh
+        run: |
+          scala --version
+          if (-not (scala --version | Select-String "Scala version \(default\): ${{ inputs.version }}")) {
+            Write-Host "Invalid Scala version of MSI installed runner, expected ${{ inputs.version }}"
+            Exit 1
+          }
+      - name : Test the `scalac` command
+        shell: pwsh
+        run: |
+          scalac --version
+          if (-not (scalac --version | Select-String "Scala compiler version ${{ inputs.version }}")) {
+            Write-Host "Invalid scalac version of MSI installed runner, expected ${{ inputs.version }}"
+            Exit 1
+          }
+      - name : Test the `scaladoc` command
+        shell: pwsh
+        run: |
+          scaladoc --version
+          if (-not (scaladoc --version | Select-String "Scaladoc version ${{ inputs.version }}")) {
+            Write-Host "Invalid scaladoc version of MSI installed runner, expected ${{ inputs.version }}"
+            Exit 1
+          }
+      - name : Uninstall the `scala` package
+        shell: pwsh
+        run: |
+          Start-Process 'msiexec.exe' -ArgumentList '/X "scala.msi" /L*V "uninstall.log" /qb' -Wait
+          Get-Content 'uninstall.log'
+        
\ No newline at end of file

From e53cb5bfa6d361124ab5b60f41efdd8708253ff6 Mon Sep 17 00:00:00 2001
From: tgodzik <tgodzik@virtuslab.com>
Date: Thu, 10 Oct 2024 18:19:03 +0200
Subject: [PATCH 069/306] improvement: Remove workaround for Bloop and update
 docs

---
 .../_docs/contributing/setting-up-your-ide.md | 24 +++++++-------
 project/Build.scala                           |  4 +--
 project/NoBloopExport.scala                   | 31 -------------------
 3 files changed, 14 insertions(+), 45 deletions(-)
 delete mode 100644 project/NoBloopExport.scala

diff --git a/docs/_docs/contributing/setting-up-your-ide.md b/docs/_docs/contributing/setting-up-your-ide.md
index a02c1dee63cb..a15bf651ef74 100644
--- a/docs/_docs/contributing/setting-up-your-ide.md
+++ b/docs/_docs/contributing/setting-up-your-ide.md
@@ -3,16 +3,15 @@ layout: doc-page
 title: Setting up your IDE
 ---
 
-You can use either Metals with your favorite editor (VS Code, Neovim, Sublime)
-or [IntelliJ IDEA for
-Scala](https://www.jetbrains.com/help/idea/discover-intellij-idea-for-scala.html)
+You can use either Metals with your favorite editor or
+[IntelliJ IDEA for Scala](https://www.jetbrains.com/help/idea/discover-intellij-idea-for-scala.html)
 to work on the Scala 3 codebase. There are however a few additional
 considerations to take into account.
 
 ## Bootstrapping Projects
 
-The sbt build for dotty implements bootstrapping within the same build, so each component has
-two projects:
+The sbt build for dotty implements bootstrapping within the same build, so each
+component has two projects:
 
 ```
 sbt:scala3> projects
@@ -33,9 +32,9 @@ you'll actually want these modules exported. In order to achieve this you'll
 want to make sure you do two things:
 
 1. You'll want to find and change the following under
-    `commonBootstrappedSettings` which is found in the
-    [`Build.scala`](https://github.com/scala/scala3/blob/main/project/Build.scala)
-    file.
+   `commonBootstrappedSettings` which is found in the
+   [`Build.scala`](https://github.com/scala/scala3/blob/main/project/Build.scala)
+   file.
 
 ```diff
 
@@ -43,12 +42,13 @@ want to make sure you do two things:
 +    bspEnabled := true,
 ```
 
-2. Set `sbt` as your build server instead of the default, Bloop. You can achieve
-    this with the `Metals: Switch Build Server` command and then choosing sbt. In
-    VSCode, this looks like this:
+2. Run `sbt publishLocal` to get the needed presentation compiler jars.
 
-![bsp-switch](https://user-images.githubusercontent.com/777748/241986423-0724ae74-0ebd-42ef-a1b7-4d17678992b4.png)
+By default Metals uses Bloop build server, however you can also use sbt
+directly. You can achieve this with the `Metals: Switch Build Server` command
+and then choosing sbt. In VSCode, this looks like this:
 
+![bsp-switch](https://user-images.githubusercontent.com/777748/241986423-0724ae74-0ebd-42ef-a1b7-4d17678992b4.png)
 
 ### IntelliJ
 
diff --git a/project/Build.scala b/project/Build.scala
index 84ce00d11577..6ec933a599b3 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -469,8 +469,8 @@ object Build {
   }
 
   // Settings used when compiling dotty with a non-bootstrapped dotty
-  lazy val commonBootstrappedSettings = commonDottySettings ++ NoBloopExport.settings ++ Seq(
-    // To enable support of scaladoc and language-server projects you need to change this to true and use sbt as your build server
+  lazy val commonBootstrappedSettings = commonDottySettings ++ Seq(
+    // To enable support of scaladoc and language-server projects you need to change this to true
     bspEnabled := false,
     (Compile / unmanagedSourceDirectories) += baseDirectory.value / "src-bootstrapped",
 
diff --git a/project/NoBloopExport.scala b/project/NoBloopExport.scala
deleted file mode 100644
index 7a088a405781..000000000000
--- a/project/NoBloopExport.scala
+++ /dev/null
@@ -1,31 +0,0 @@
-import sbt._
-import Keys._
-
-/* With <3 from scala-js */
-object NoBloopExport {
-  private lazy val bloopGenerateKey: Option[TaskKey[Result[Option[File]]]] = {
-    val optBloopKeysClass: Option[Class[_]] = try {
-      Some(Class.forName("bloop.integrations.sbt.BloopKeys"))
-    } catch {
-      case _: ClassNotFoundException => None
-    }
-
-    optBloopKeysClass.map { bloopKeysClass =>
-      val bloopGenerateGetter = bloopKeysClass.getMethod("bloopGenerate")
-      bloopGenerateGetter.invoke(null).asInstanceOf[TaskKey[Result[Option[File]]]]
-    }
-  }
-
-  /** Settings to prevent the project from being exported to IDEs. */
-  lazy val settings: Seq[Setting[_]] = {
-    bloopGenerateKey match {
-      case None =>
-        Nil
-      case Some(key) =>
-        Seq(
-            Compile / key := Value(None),
-            Test / key := Value(None),
-        )
-    }
-  }
-}

From e6b7e3d06faf4b833fd03fe73b5610362b8f4b8c Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Thu, 24 Oct 2024 23:47:16 +0200
Subject: [PATCH 070/306] Better error message for polytypes wrapping capturing
 types

A type like

    [X] -> A ->{c} B

is currently not allowed since it expands to a PolyType wrapping a CapturingType and we
have an implementation restriction that requires PolyTypes to wrap only FunctionTypes. It
would be great if we could lift that implementation restriction. Until we do so, we should
have a better error message, which is commit implements.
---
 .../dotty/tools/dotc/parsing/Parsers.scala    | 38 +++++++++----------
 .../captures/polyCaptures.check               |  8 ++++
 .../captures/polyCaptures.scala               |  7 ++++
 3 files changed, 33 insertions(+), 20 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/polyCaptures.check
 create mode 100644 tests/neg-custom-args/captures/polyCaptures.scala

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index d933e55a9823..293b5590fec6 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -518,6 +518,22 @@ object Parsers {
         tree
     }
 
+    def makePolyFunction(tparams: List[Tree], body: Tree,
+        kind: String, errorTree: => Tree,
+        start: Offset, arrowOffset: Offset): Tree =
+      atSpan(start, arrowOffset):
+        getFunction(body) match
+          case None =>
+            syntaxError(em"Implementation restriction: polymorphic function ${kind}s must have a value parameter", arrowOffset)
+            errorTree
+          case Some(Function(_, _: CapturesAndResult)) =>
+            // A function tree like this will be desugared
+            // into a capturing type in the typer.
+            syntaxError(em"Implementation restriction: polymorphic function types cannot wrap function types that have capture sets", arrowOffset)
+            errorTree
+          case Some(f) =>
+            PolyFunction(tparams, body)
+
 /* --------------- PLACEHOLDERS ------------------------------------------- */
 
     /** The implicit parameters introduced by `_` in the current expression.
@@ -1539,11 +1555,6 @@ object Parsers {
     private def getFunction(tree: Tree): Option[Function] = tree match {
       case Parens(tree1) => getFunction(tree1)
       case Block(Nil, tree1) => getFunction(tree1)
-      case Function(_, _: CapturesAndResult) =>
-        // A function tree like this will be desugared
-        // into a capturing type in the typer,
-        // so None is returned.
-        None
       case t: Function => Some(t)
       case _ => None
     }
@@ -1757,13 +1768,7 @@ object Parsers {
         else if in.token == ARROW || isPureArrow(nme.PUREARROW) then
           val arrowOffset = in.skipToken()
           val body = toplevelTyp(nestedIntoOK(in.token))
-          atSpan(start, arrowOffset):
-            getFunction(body) match
-              case Some(f) =>
-                PolyFunction(tparams, body)
-              case None =>
-                syntaxError(em"Implementation restriction: polymorphic function types must have a value parameter", arrowOffset)
-                Ident(nme.ERROR.toTypeName)
+          makePolyFunction(tparams, body, "type", Ident(nme.ERROR.toTypeName), start, arrowOffset)
         else
           accept(TLARROW)
           typ()
@@ -2360,14 +2365,7 @@ object Parsers {
           val tparams = typeParamClause(ParamOwner.Type)
           val arrowOffset = accept(ARROW)
           val body = expr(location)
-          atSpan(start, arrowOffset) {
-            getFunction(body) match
-              case Some(f) =>
-                PolyFunction(tparams, f)
-              case None =>
-                syntaxError(em"Implementation restriction: polymorphic function literals must have a value parameter", arrowOffset)
-                errorTermTree(arrowOffset)
-          }
+          makePolyFunction(tparams, body, "literal", errorTermTree(arrowOffset), start, arrowOffset)
         case _ =>
           val saved = placeholderParams
           placeholderParams = Nil
diff --git a/tests/neg-custom-args/captures/polyCaptures.check b/tests/neg-custom-args/captures/polyCaptures.check
new file mode 100644
index 000000000000..8173828b7bc8
--- /dev/null
+++ b/tests/neg-custom-args/captures/polyCaptures.check
@@ -0,0 +1,8 @@
+-- Error: tests/neg-custom-args/captures/polyCaptures.scala:4:22 -------------------------------------------------------
+4 |val runOpsCheck: [C^] -> (ops: List[() ->{C^} Unit]) ->{C^} Unit = runOps  // error
+  |                      ^
+  |          Implementation restriction: polymorphic function types cannot wrap function types that have capture sets
+-- Error: tests/neg-custom-args/captures/polyCaptures.scala:5:23 -------------------------------------------------------
+5 |val runOpsCheck2: [C^] => (ops: List[() ->{C^} Unit]) ->{C^} Unit = runOps // error
+  |                       ^
+  |          Implementation restriction: polymorphic function types cannot wrap function types that have capture sets
diff --git a/tests/neg-custom-args/captures/polyCaptures.scala b/tests/neg-custom-args/captures/polyCaptures.scala
new file mode 100644
index 000000000000..776af95e5dcf
--- /dev/null
+++ b/tests/neg-custom-args/captures/polyCaptures.scala
@@ -0,0 +1,7 @@
+class Box[X](val elem: X)
+
+val runOps = [C^] => (b: Box[() ->{C^} Unit]) => b.elem()
+val runOpsCheck: [C^] -> (ops: List[() ->{C^} Unit]) ->{C^} Unit = runOps  // error
+val runOpsCheck2: [C^] => (ops: List[() ->{C^} Unit]) ->{C^} Unit = runOps // error
+
+

From fcfa6b0a43a4e477867d5e27404946a9de0b9d24 Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Thu, 24 Oct 2024 16:10:53 +0200
Subject: [PATCH 071/306] Remove redundant `with Checking`

`ReTyper` already extends `Typer` which extends `Checking`
---
 compiler/src/dotty/tools/dotc/transform/TreeChecker.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index a2b403fdae6c..c35dc80c04a5 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -236,7 +236,7 @@ object TreeChecker {
   private[TreeChecker] def isValidJVMMethodName(name: Name): Boolean = name.toString.forall(isValidJVMMethodChar)
 
 
-  class Checker(phasesToCheck: Seq[Phase]) extends ReTyper with Checking {
+  class Checker(phasesToCheck: Seq[Phase]) extends ReTyper {
     import ast.tpd.*
 
     protected val nowDefinedSyms = util.HashSet[Symbol]()

From eb12bfe3f20ca9ad0e395ba20e52d64f084b8c4b Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Fri, 25 Oct 2024 18:03:21 +0200
Subject: [PATCH 072/306] Pretty-print lambdas

---
 .../tools/dotc/printing/RefinedPrinter.scala  |  4 +++
 tests/printing/annot-19846b.check             | 18 ++---------
 tests/printing/lambdas.check                  | 30 +++++++++++++++++++
 tests/printing/lambdas.scala                  | 14 +++++++++
 4 files changed, 50 insertions(+), 16 deletions(-)
 create mode 100644 tests/printing/lambdas.check
 create mode 100644 tests/printing/lambdas.scala

diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index b229c7ec29d9..95df9f84c723 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -17,6 +17,7 @@ import Denotations.*
 import SymDenotations.*
 import StdNames.{nme, tpnme}
 import ast.{Trees, tpd, untpd}
+import tpd.closureDef
 import typer.{Implicits, Namer, Applications}
 import typer.ProtoTypes.*
 import Trees.*
@@ -510,6 +511,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         toText(name) ~ (if name.isTermName && arg.isType then " : " else " = ") ~ toText(arg)
       case Assign(lhs, rhs) =>
         changePrec(GlobalPrec) { toTextLocal(lhs) ~ " = " ~ toText(rhs) }
+      case closureDef(meth) if !printDebug =>
+        withEnclosingDef(meth):
+          meth.paramss.map(paramsText).foldRight(toText(meth.rhs))(_ ~ " => " ~ _)
       case block: Block =>
         blockToText(block)
       case If(cond, thenp, elsep) =>
diff --git a/tests/printing/annot-19846b.check b/tests/printing/annot-19846b.check
index 3f63a46c4286..3633b1c9e9ad 100644
--- a/tests/printing/annot-19846b.check
+++ b/tests/printing/annot-19846b.check
@@ -7,27 +7,13 @@ package <empty> {
   final lazy module val Test: Test = new Test()
   final module class Test() extends Object() { this: Test.type =>
     val y: Int = ???
-    val z:
-      Int @lambdaAnnot(
-        {
-          def $anonfun(): Int = Test.y
-          closure($anonfun)
-        }
-      )
-     = f(Test.y)
+    val z: Int @lambdaAnnot(() => Test.y) = f(Test.y)
   }
   final lazy module val annot-19846b$package: annot-19846b$package =
     new annot-19846b$package()
   final module class annot-19846b$package() extends Object() {
     this: annot-19846b$package.type =>
-    def f(x: Int):
-      Int @lambdaAnnot(
-        {
-          def $anonfun(): Int = x
-          closure($anonfun)
-        }
-      )
-     = x
+    def f(x: Int): Int @lambdaAnnot(() => x) = x
   }
 }
 
diff --git a/tests/printing/lambdas.check b/tests/printing/lambdas.check
new file mode 100644
index 000000000000..887a8f2ded35
--- /dev/null
+++ b/tests/printing/lambdas.check
@@ -0,0 +1,30 @@
+[[syntax trees at end of                     typer]] // tests/printing/lambdas.scala
+package <empty> {
+  final lazy module val Main: Main = new Main()
+  final module class Main() extends Object() { this: Main.type =>
+    val f1: Int => Int = (x: Int) => x.+(1)
+    val f2: (Int, Int) => Int = (x: Int, y: Int) => x.+(y)
+    val f3: Int => Int => Int = (x: Int) => (y: Int) => x.+(y)
+    val f4: [T] => (x: Int) => Int = [T >: Nothing <: Any] => (x: Int) => x.+(1)
+    val f5: [T] => (x: Int) => Int => Int = [T >: Nothing <: Any] => (x: Int)
+       => (y: Int) => x.+(y)
+    val f6: Int => Int = (x: Int) =>
+      {
+        val x2: Int = x.+(1)
+        x2.+(1)
+      }
+    def f7(x: Int): Int = x.+(1)
+    val f8: Int => Int = (x: Int) => Main.f7(x)
+    val l: List[Int] = List.apply[Int]([1,2,3 : Int]*)
+    Main.l.map[Int]((_$1: Int) => _$1.+(1))
+    Main.l.map[Int]((x: Int) => x.+(1))
+    Main.l.map[Int]((x: Int) =>
+      {
+        val x2: Int = x.+(1)
+        x2.+(1)
+      }
+    )
+    Main.l.map[Int]((x: Int) => Main.f7(x))
+  }
+}
+
diff --git a/tests/printing/lambdas.scala b/tests/printing/lambdas.scala
new file mode 100644
index 000000000000..8df7db3e6dda
--- /dev/null
+++ b/tests/printing/lambdas.scala
@@ -0,0 +1,14 @@
+object Main:
+  val f1 = (x: Int) => x + 1
+  val f2 = (x: Int, y: Int) => x + y
+  val f3 = (x: Int) => (y: Int) => x + y
+  val f4 = [T] => (x: Int) => x + 1
+  val f5 = [T] => (x: Int) => (y: Int) => x + y
+  val f6 = (x: Int) => { val x2 = x + 1; x2 + 1 }
+  def f7(x: Int) = x + 1
+  val f8 = f7
+  val l = List(1,2,3)
+  l.map(_ + 1)
+  l.map(x => x + 1)
+  l.map(x => { val x2 = x + 1; x2 + 1 })
+  l.map(f7)

From 305cb9caae2285c1d1bd626f13cdaa42e432223e Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Wed, 18 Sep 2024 15:33:16 +0200
Subject: [PATCH 073/306] Add path support for cc

---
 compiler/src/dotty/tools/dotc/ast/untpd.scala |   4 +-
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  |   3 +-
 .../src/dotty/tools/dotc/cc/CaptureRef.scala  |  84 +++++++++-----
 .../src/dotty/tools/dotc/cc/CaptureSet.scala  |   8 +-
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 106 ++++++++++--------
 .../dotty/tools/dotc/parsing/Parsers.scala    |  28 ++---
 .../captures/class-contra.check               |  13 +--
 .../captures/class-contra.scala               |   3 +-
 .../captures/explain-under-approx.check       |  14 +--
 .../captures/filevar-multi-ios.scala          |  41 +++++++
 tests/neg-custom-args/captures/i15116.check   |  16 ++-
 tests/neg-custom-args/captures/path-box.scala |  20 ++++
 .../captures/path-connection.scala            |  46 ++++++++
 .../captures/path-illigal.scala               |   7 ++
 .../captures/path-simple.scala                |  27 +++++
 .../neg-custom-args/captures/singletons.scala |   8 +-
 .../captures/filevar-expanded.scala           |   3 +-
 tests/pos-custom-args/captures/filevar.scala  |   3 +-
 18 files changed, 314 insertions(+), 120 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/filevar-multi-ios.scala
 create mode 100644 tests/neg-custom-args/captures/path-box.scala
 create mode 100644 tests/neg-custom-args/captures/path-connection.scala
 create mode 100644 tests/neg-custom-args/captures/path-illigal.scala
 create mode 100644 tests/neg-custom-args/captures/path-simple.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index 935e42d5e05c..4684464d477f 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -524,8 +524,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def makeRetaining(parent: Tree, refs: List[Tree], annotName: TypeName)(using Context): Annotated =
     Annotated(parent, New(scalaAnnotationDot(annotName), List(refs)))
 
-  def makeCapsOf(id: Ident)(using Context): Tree =
-    TypeApply(Select(scalaDot(nme.caps), nme.capsOf), id :: Nil)
+  def makeCapsOf(tp: Tree)(using Context): Tree =
+    TypeApply(Select(scalaDot(nme.caps), nme.capsOf), tp :: Nil)
 
   def makeCapsBound()(using Context): Tree =
     makeRetaining(
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index 29c6528e36de..79cc7d136e45 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -194,7 +194,8 @@ extension (tp: Type)
       true
     case tp: TermRef =>
       ((tp.prefix eq NoPrefix)
-      || tp.symbol.is(ParamAccessor) && tp.prefix.isThisTypeOf(tp.symbol.owner)
+      || tp.symbol.isField && !tp.symbol.isStatic && (
+        tp.prefix.isThisTypeOf(tp.symbol.owner) || tp.prefix.isTrackableRef)
       || tp.isRootCapability
       ) && !tp.symbol.isOneOf(UnstableValueFlags)
     case tp: TypeRef =>
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
index f00c6869cd80..05162907b608 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
@@ -61,18 +61,19 @@ trait CaptureRef extends TypeProxy, ValueType:
     case tp: TermParamRef => tp.underlying.derivesFrom(defn.Caps_Exists)
     case _ => false
 
-  /** Normalize reference so that it can be compared with `eq` for equality */
-  final def normalizedRef(using Context): CaptureRef = this match
-    case tp @ AnnotatedType(parent: CaptureRef, annot) if tp.isTrackableRef =>
-      tp.derivedAnnotatedType(parent.normalizedRef, annot)
-    case tp: TermRef if tp.isTrackableRef =>
-      tp.symbol.termRef
-    case _ => this
+  // With the support of pathes, we don't need to normalize the `TermRef`s anymore.
+  // /** Normalize reference so that it can be compared with `eq` for equality */
+  // final def normalizedRef(using Context): CaptureRef = this match
+  //   case tp @ AnnotatedType(parent: CaptureRef, annot) if tp.isTrackableRef =>
+  //     tp.derivedAnnotatedType(parent.normalizedRef, annot)
+  //   case tp: TermRef if tp.isTrackableRef =>
+  //     tp.symbol.termRef
+  //   case _ => this
 
   /** The capture set consisting of exactly this reference */
   final def singletonCaptureSet(using Context): CaptureSet.Const =
     if mySingletonCaptureSet == null then
-      mySingletonCaptureSet = CaptureSet(this.normalizedRef)
+      mySingletonCaptureSet = CaptureSet(this)
     mySingletonCaptureSet.uncheckedNN
 
   /** The capture set of the type underlying this reference */
@@ -99,25 +100,56 @@ trait CaptureRef extends TypeProxy, ValueType:
    *   x: x1.type /\ x1 subsumes y  ==>  x subsumes y
    */
   final def subsumes(y: CaptureRef)(using Context): Boolean =
-    (this eq y)
-    || this.isRootCapability
-    || y.match
-        case y: TermRef =>
-          (y.prefix eq this)
-          || y.info.match
-              case y1: SingletonCaptureRef => this.subsumes(y1)
-              case _ => false
-        case MaybeCapability(y1) => this.stripMaybe.subsumes(y1)
-        case _ => false
-    || this.match
-        case ReachCapability(x1) => x1.subsumes(y.stripReach)
-        case x: TermRef =>
-          x.info match
-            case x1: SingletonCaptureRef => x1.subsumes(y)
+    def compareCaptureRefs(x: Type, y: Type): Boolean =
+      (x eq y)
+      || y.match
+          case y: CaptureRef => x.match
+            case x: CaptureRef => x.subsumes(y)
             case _ => false
-        case x: TermParamRef => subsumesExistentially(x, y)
-        case x: TypeRef => assumedContainsOf(x).contains(y)
-        case _ => false
+          case _ => false
+
+    def compareUndelying(x: Type): Boolean = x match
+      case x: SingletonCaptureRef => x.subsumes(y)
+      case x: AndType => compareUndelying(x.tp1) || compareUndelying(x.tp2)
+      case x: OrType => compareUndelying(x.tp1) && compareUndelying(x.tp2)
+      case _ => false
+
+    if (this eq y) || this.isRootCapability then return true
+
+    // similar to compareNamed in TypeComparer
+    y match
+      case y: TermRef =>
+        this match
+          case x: TermRef =>
+            val xSym = x.symbol
+            val ySym = y.symbol
+
+            // check x.f and y.f
+            if (xSym ne NoSymbol)
+                && (xSym eq ySym)
+                && compareCaptureRefs(x.prefix, y.prefix)
+              || (x.name eq y.name)
+                && x.isPrefixDependentMemberRef
+                && compareCaptureRefs(x.prefix, y.prefix)
+                && x.signature == y.signature
+                && !(xSym.isClass && ySym.isClass)
+            then return true
+          case _ =>
+
+        // shorten
+        if compareCaptureRefs(this, y.prefix) then return true
+        // underlying
+        if compareCaptureRefs(this, y.info) then return true
+      case MaybeCapability(y1) => return this.stripMaybe.subsumes(y1)
+      case _ =>
+
+    return this.match
+      case ReachCapability(x1) => x1.subsumes(y.stripReach)
+      case x: TermRef => compareUndelying(x.info)
+      case CapturingType(x1, _) => compareUndelying(x1)
+      case x: TermParamRef => subsumesExistentially(x, y)
+      case x: TypeRef => assumedContainsOf(x).contains(y)
+      case _ => false
 
   def assumedContainsOf(x: TypeRef)(using Context): SimpleIdentitySet[CaptureRef] =
     CaptureSet.assumedContains.getOrElse(x, SimpleIdentitySet.empty)
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
index 44d5e2cf4b88..81b4287961ba 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
@@ -374,7 +374,7 @@ object CaptureSet:
 
   def apply(elems: CaptureRef*)(using Context): CaptureSet.Const =
     if elems.isEmpty then empty
-    else Const(SimpleIdentitySet(elems.map(_.normalizedRef.ensuring(_.isTrackableRef))*))
+    else Const(SimpleIdentitySet(elems.map(_.ensuring(_.isTrackableRef))*))
 
   def apply(elems: Refs)(using Context): CaptureSet.Const =
     if elems.isEmpty then empty else Const(elems)
@@ -508,7 +508,11 @@ object CaptureSet:
         !noUniversal
       else elem match
         case elem: TermRef if level.isDefined =>
-          elem.symbol.ccLevel <= level
+          elem.prefix match
+            case prefix: CaptureRef =>
+              levelOK(prefix)
+            case _ =>
+              elem.symbol.ccLevel <= level
         case elem: ThisType if level.isDefined =>
           elem.cls.ccLevel.nextInner <= level
         case ReachCapability(elem1) =>
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index b05ab8542137..ec1e63137311 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -122,10 +122,6 @@ object CheckCaptures:
    *  This check is performed at Typer.
    */
   def checkWellformed(parent: Tree, ann: Tree)(using Context): Unit =
-    parent.tpe match
-      case _: SingletonType =>
-        report.error(em"Singleton type $parent cannot have capture set", parent.srcPos)
-      case _ =>
     def check(elem: Tree, pos: SrcPos): Unit = elem.tpe match
       case ref: CaptureRef =>
         if !ref.isTrackableRef then
@@ -373,45 +369,54 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  the environment's owner
      */
     def markFree(cs: CaptureSet, pos: SrcPos)(using Context): Unit =
+      // A captured reference with the symbol `sym` is visible from the environment
+      // if `sym` is not defined inside the owner of the environment.
+      inline def isVisibleFromEnv(sym: Symbol, env: Env) =
+        if env.kind == EnvKind.NestedInOwner then
+          !sym.isProperlyContainedIn(env.owner)
+        else
+          !sym.isContainedIn(env.owner)
+
+      def checkSubsetEnv(cs: CaptureSet, env: Env)(using Context): Unit =
+        // Only captured references that are visible from the environment
+        // should be included.
+        val included = cs.filter: c =>
+          c.stripReach match
+            case ref: NamedType =>
+              val refSym = ref.symbol
+              val refOwner = refSym.owner
+              val isVisible = isVisibleFromEnv(refOwner, env)
+              if isVisible && !ref.isRootCapability then
+                ref match
+                  case ref: TermRef if ref.prefix `ne` NoPrefix =>
+                    // If c is a path of a class defined outside the environment,
+                    // we check the capture set of its info.
+                    checkSubsetEnv(ref.captureSetOfInfo, env)
+                  case _ =>
+              if !isVisible
+                  && (c.isReach || ref.isType)
+                  && (!ccConfig.useSealed || refSym.is(Param))
+                  && refOwner == env.owner
+              then
+                if refSym.hasAnnotation(defn.UnboxAnnot) then
+                  capt.println(i"exempt: $ref in $refOwner")
+                else
+                  // Reach capabilities that go out of scope have to be approximated
+                  // by their underlying capture set, which cannot be universal.
+                  // Reach capabilities of @unboxed parameters are exempted.
+                  val cs = CaptureSet.ofInfo(c)
+                  cs.disallowRootCapability: () =>
+                    report.error(em"Local reach capability $c leaks into capture scope of ${env.ownerString}", pos)
+                  checkSubset(cs, env.captured, pos, provenance(env))
+              isVisible
+            case ref: ThisType => isVisibleFromEnv(ref.cls, env)
+            case _ => false
+        checkSubset(included, env.captured, pos, provenance(env))
+        capt.println(i"Include call or box capture $included from $cs in ${env.owner} --> ${env.captured}")
+
       if !cs.isAlwaysEmpty then
         forallOuterEnvsUpTo(ctx.owner.topLevelClass): env =>
-          // Whether a symbol is defined inside the owner of the environment?
-          inline def isContainedInEnv(sym: Symbol) =
-            if env.kind == EnvKind.NestedInOwner then
-              sym.isProperlyContainedIn(env.owner)
-            else
-              sym.isContainedIn(env.owner)
-          // A captured reference with the symbol `sym` is visible from the environment
-          // if `sym` is not defined inside the owner of the environment
-          inline def isVisibleFromEnv(sym: Symbol) = !isContainedInEnv(sym)
-          // Only captured references that are visible from the environment
-          // should be included.
-          val included = cs.filter: c =>
-            c.stripReach match
-              case ref: NamedType =>
-                val refSym = ref.symbol
-                val refOwner = refSym.owner
-                val isVisible = isVisibleFromEnv(refOwner)
-                if !isVisible
-                    && (c.isReach || ref.isType)
-                    && (!ccConfig.useSealed || refSym.is(Param))
-                    && refOwner == env.owner
-                then
-                  if refSym.hasAnnotation(defn.UnboxAnnot) then
-                    capt.println(i"exempt: $ref in $refOwner")
-                  else
-                    // Reach capabilities that go out of scope have to be approximated
-                    // by their underlying capture set, which cannot be universal.
-                    // Reach capabilities of @unboxed parameters are exempted.
-                    val cs = CaptureSet.ofInfo(c)
-                    cs.disallowRootCapability: () =>
-                      report.error(em"Local reach capability $c leaks into capture scope of ${env.ownerString}", pos)
-                    checkSubset(cs, env.captured, pos, provenance(env))
-                isVisible
-              case ref: ThisType => isVisibleFromEnv(ref.cls)
-              case _ => false
-          checkSubset(included, env.captured, pos, provenance(env))
-          capt.println(i"Include call or box capture $included from $cs in ${env.owner} --> ${env.captured}")
+          checkSubsetEnv(cs, env)
     end markFree
 
     /** Include references captured by the called method in the current environment stack */
@@ -488,21 +493,28 @@ class CheckCaptures extends Recheck, SymTransformer:
         case _ => denot
 
       val selType = recheckSelection(tree, qualType, name, disambiguate)
-      val selCs = selType.widen.captureSet
-      if selCs.isAlwaysEmpty
-          || selType.widen.isBoxedCapturing
+      val selWiden = selType.widen
+      def isStableSel = selType match
+        case selType: NamedType => selType.symbol.isStableMember
+        case _ => false
+        
+      if pt == LhsProto
           || qualType.isBoxedCapturing
-          || pt == LhsProto
+          || selType.isTrackableRef
+          || selWiden.isBoxedCapturing
+          || selWiden.captureSet.isAlwaysEmpty
       then
         selType
       else
         val qualCs = qualType.captureSet
-        capt.println(i"pick one of $qualType, ${selType.widen}, $qualCs, $selCs in $tree")
+        val selCs = selType.captureSet
+        capt.println(i"pick one of $qualType, ${selType.widen}, $qualCs, $selCs ${selWiden.captureSet} in $tree")
+
         if qualCs.mightSubcapture(selCs)
             && !selCs.mightSubcapture(qualCs)
             && !pt.stripCapturing.isInstanceOf[SingletonType]
         then
-          selType.widen.stripCapturing.capturing(qualCs)
+          selWiden.stripCapturing.capturing(qualCs)
             .showing(i"alternate type for select $tree: $selType --> $result, $qualCs / $selCs", capt)
         else
           selType
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 47391a4114cf..dc3ae4cf7639 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1559,21 +1559,23 @@ object Parsers {
       case _ => None
     }
 
-    /** CaptureRef  ::=  ident [`*` | `^`] | `this`
+    /** CaptureRef  ::=  (ident | `this`) [`*` | `^`]
      */
     def captureRef(): Tree =
-      if in.token == THIS then simpleRef()
-      else
-        val id = termIdent()
-        if isIdent(nme.raw.STAR) then
-          in.nextToken()
-          atSpan(startOffset(id)):
-            PostfixOp(id, Ident(nme.CC_REACH))
-        else if isIdent(nme.UPARROW) then
-          in.nextToken()
-          atSpan(startOffset(id)):
-            makeCapsOf(cpy.Ident(id)(id.name.toTypeName))
-        else id
+      val ref = singleton()
+      if isIdent(nme.raw.STAR) then
+        in.nextToken()
+        atSpan(startOffset(ref)):
+          PostfixOp(ref, Ident(nme.CC_REACH))
+      else if isIdent(nme.UPARROW) then
+        in.nextToken()
+        def toTypeSel(r: Tree): Tree = r match
+          case id: Ident => cpy.Ident(id)(id.name.toTypeName)
+          case Select(qual, id) => Select(qual, id.toTypeName)
+          case _ => r
+        atSpan(startOffset(ref)):
+          makeCapsOf(toTypeSel(ref))
+      else ref
 
     /**  CaptureSet ::=  `{` CaptureRef {`,` CaptureRef} `}`    -- under captureChecking
      */
diff --git a/tests/neg-custom-args/captures/class-contra.check b/tests/neg-custom-args/captures/class-contra.check
index 9fc009ac3d48..808118bd1795 100644
--- a/tests/neg-custom-args/captures/class-contra.check
+++ b/tests/neg-custom-args/captures/class-contra.check
@@ -1,10 +1,7 @@
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/class-contra.scala:12:39 ---------------------------------
-12 |  def fun(x: K{val f: T^{a}}) = x.setf(a) // error
-   |                                       ^
-   |   Found:    (a : T^{x, y})
-   |   Required: T^{}
-   |
-   |   Note that a capability (K.this.f : T^) in a capture set appearing in contravariant position
-   |   was mapped to (x.f : T^{a}) which is not a capability. Therefore, it was under-approximated to the empty set.
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/class-contra.scala:12:40 ---------------------------------
+12 |  def fun1(k: K{val f: T^{a}}) = k.setf(a) // error
+   |                                        ^
+   |                                        Found:    (a : T^{x, y})
+   |                                        Required: T^{k.f}
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/class-contra.scala b/tests/neg-custom-args/captures/class-contra.scala
index 210fd4e331f1..8ef8e7485a18 100644
--- a/tests/neg-custom-args/captures/class-contra.scala
+++ b/tests/neg-custom-args/captures/class-contra.scala
@@ -9,5 +9,6 @@ class T
 
 def test(x: Cap, y: Cap) =
   val a: T^{x, y} = ???
-  def fun(x: K{val f: T^{a}}) = x.setf(a) // error
+  def fun1(k: K{val f: T^{a}}) = k.setf(a) // error
+  def fun2(k: K{val f: a.type}) = k.setf(a)
   ()
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/explain-under-approx.check b/tests/neg-custom-args/captures/explain-under-approx.check
index 2d2b05b4b95a..c186fc6adb11 100644
--- a/tests/neg-custom-args/captures/explain-under-approx.check
+++ b/tests/neg-custom-args/captures/explain-under-approx.check
@@ -1,20 +1,14 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/explain-under-approx.scala:12:10 -------------------------
 12 |  col.add(Future(() => 25)) // error
    |          ^^^^^^^^^^^^^^^^
-   |       Found:    Future[Int]{val a: (async : Async^)}^{async}
-   |       Required: Future[Int]^{}
-   |
-   |       Note that a capability Collector.this.futs* in a capture set appearing in contravariant position
-   |       was mapped to col.futs* which is not a capability. Therefore, it was under-approximated to the empty set.
+   |          Found:    Future[Int]{val a: (async : Async^)}^{async}
+   |          Required: Future[Int]^{col.futs*}
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/explain-under-approx.scala:15:11 -------------------------
 15 |  col1.add(Future(() => 25)) // error
    |           ^^^^^^^^^^^^^^^^
-   |      Found:    Future[Int]{val a: (async : Async^)}^{async}
-   |      Required: Future[Int]^{}
-   |
-   |      Note that a capability Collector.this.futs* in a capture set appearing in contravariant position
-   |      was mapped to col1.futs* which is not a capability. Therefore, it was under-approximated to the empty set.
+   |           Found:    Future[Int]{val a: (async : Async^)}^{async}
+   |           Required: Future[Int]^{col1.futs*}
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/filevar-multi-ios.scala b/tests/neg-custom-args/captures/filevar-multi-ios.scala
new file mode 100644
index 000000000000..8ffc8d8e299c
--- /dev/null
+++ b/tests/neg-custom-args/captures/filevar-multi-ios.scala
@@ -0,0 +1,41 @@
+import language.experimental.modularity
+import compiletime.uninitialized
+
+class IO extends caps.Capability
+
+class File:
+  def write(x: String): Unit = ???
+
+object test1:
+
+  class Service(val io: IO, val io2: IO):
+    var file: File^{io} = uninitialized
+    var file2: File^{io2} = uninitialized
+    def log = file.write("log")
+
+  def withFile[T](io: IO)(op: File^{io} => T): T =
+    op(new File)
+
+  def test(io3: IO, io4: IO) =
+    withFile(io3): f =>
+      val o = Service(io3, io4)
+      o.file = f // error
+      o.file2 = f // error
+      o.log
+
+object test2:
+
+  class Service(tracked val io: IO, tracked val io2: IO):
+    var file: File^{io} = uninitialized
+    var file2: File^{io2} = uninitialized
+    def log = file.write("log")
+
+  def withFile[T](io: IO)(op: File^{io} => T): T =
+    op(new File)
+
+  def test(io3: IO, io4: IO) =
+    withFile(io3): f =>
+      val o = Service(io3, io4)
+      o.file = f
+      o.file2 = f // error
+      o.log
diff --git a/tests/neg-custom-args/captures/i15116.check b/tests/neg-custom-args/captures/i15116.check
index df05324866e1..0a16af9f6704 100644
--- a/tests/neg-custom-args/captures/i15116.check
+++ b/tests/neg-custom-args/captures/i15116.check
@@ -18,13 +18,17 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15116.scala:5:13 ----------------------------------------
 5 |  val x = Foo(m)   // error
   |          ^^^^^^
-  |          Found:    Foo{val m: String^{Baz.this}}^{Baz.this}
+  |          Found:    Foo{val m²: (Baz.this.m : String^)}^{Baz.this.m}
   |          Required: Foo
   |
+  |          where:    m  is a value in trait Baz
+  |                    m² is a value in class Foo
+  |
+  |
   |          Note that the expected type Foo
   |          is the previously inferred type of value x
   |          which is also the type seen in separately compiled sources.
-  |          The new inferred type Foo{val m: String^{Baz.this}}^{Baz.this}
+  |          The new inferred type Foo{val m: (Baz.this.m : String^)}^{Baz.this.m}
   |          must conform to this type.
   |
   | longer explanation available when compiling with `-explain`
@@ -48,13 +52,17 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15116.scala:9:13 ----------------------------------------
 9 |  val x = Foo(m)   // error
   |          ^^^^^^
-  |          Found:    Foo{val m: String^{Baz2.this}}^{Baz2.this}
+  |          Found:    Foo{val m²: (Baz2.this.m : String^)}^{Baz2.this.m}
   |          Required: Foo
   |
+  |          where:    m  is a value in trait Baz2
+  |                    m² is a value in class Foo
+  |
+  |
   |          Note that the expected type Foo
   |          is the previously inferred type of value x
   |          which is also the type seen in separately compiled sources.
-  |          The new inferred type Foo{val m: String^{Baz2.this}}^{Baz2.this}
+  |          The new inferred type Foo{val m: (Baz2.this.m : String^)}^{Baz2.this.m}
   |          must conform to this type.
   |
   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/path-box.scala b/tests/neg-custom-args/captures/path-box.scala
new file mode 100644
index 000000000000..3213c236aaf5
--- /dev/null
+++ b/tests/neg-custom-args/captures/path-box.scala
@@ -0,0 +1,20 @@
+class A:
+  val m: A^ = ???
+  val self: this.type = this
+
+case class Box[+T](value: T)
+
+def testBox1(a: A^): Box[A^{a}] =
+  Box(a.m)
+
+def testBox2(a: A^): Box[A^{a.m}] =
+  Box(a.m)
+
+def testBox3(a: A^): Box[A^{a.m}] =
+  Box(a) // error
+
+def testBox4(a: A^): Box[A^{a.m}] =
+  Box(a.m.m.m)
+
+def testBox5(a: A^): Box[A^{a.m}] =
+  Box(a.m.m.self)
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/path-connection.scala b/tests/neg-custom-args/captures/path-connection.scala
new file mode 100644
index 000000000000..3b3820488c8d
--- /dev/null
+++ b/tests/neg-custom-args/captures/path-connection.scala
@@ -0,0 +1,46 @@
+import language.experimental.modularity
+
+trait Reader:
+  def read(): String
+
+trait Sender:
+  def send(msg: String): Unit
+
+class Connection extends Reader, Sender:
+  def read() = "hello"
+  def send(msg: String) = ()
+
+  val readOnly: Reader^ = new Reader:
+    def read() = Connection.this.read()
+
+class ReaderProxy(tracked val r: Reader^) extends Reader:
+  def read() = "(Proxy)" + r.read()
+
+class SenderProxy(tracked val s: Sender^) extends Sender:
+  def send(msg: String) = s.send("(Proxy) " + msg)
+
+def testConnection(c: Connection^)(
+    handle1: Reader^{c.readOnly} => String,
+    handle2: Sender^{c} => Unit,
+    handle3: Reader^{c} => String,
+    ) =
+  val m1 = c.read()
+  c.send("hello")
+
+  val m2 = c.readOnly.read()
+
+  val m3a = handle1(c.readOnly)
+  val m3b = handle3(c.readOnly)
+
+  val m4a = handle1(c) // error
+  val m4b = handle3(c)
+
+  val m5a = handle1(new ReaderProxy(c.readOnly))
+  val m5b = handle3(new ReaderProxy(c.readOnly))
+
+  val m6a = handle1(new ReaderProxy(c)) // error
+  val m6b = handle3(new ReaderProxy(c))
+
+  handle2(c)
+
+  handle2(new SenderProxy(c))
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/path-illigal.scala b/tests/neg-custom-args/captures/path-illigal.scala
new file mode 100644
index 000000000000..f09db0087ef7
--- /dev/null
+++ b/tests/neg-custom-args/captures/path-illigal.scala
@@ -0,0 +1,7 @@
+class A:
+  val m: A^ = ???
+  var n: A^ = ???
+
+def test1(a: A^) =
+  val c1: A^{a.m} = a.m
+  val f1: A^{a.n} = a.n // error
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/path-simple.scala b/tests/neg-custom-args/captures/path-simple.scala
new file mode 100644
index 000000000000..93b6dacebe74
--- /dev/null
+++ b/tests/neg-custom-args/captures/path-simple.scala
@@ -0,0 +1,27 @@
+
+class A:
+  val m: A^ = ???
+  val self: this.type = this
+
+case class C(ca: A^)
+
+def test1(a: A^, b: A^) =
+  val c1: A^{a} = a.m
+  val c2: A^{a.m} = a.m
+  val c3: A^{b} = a.m // error
+
+  val d1: A^{a} = a.self
+  val d2: A^{a.self} = a.self
+  val d3: A^{a.self} = a
+
+  val e1: A^{a.m} = a.self.m
+  val e2: A^{a.self.m} = a.self.m
+  val e3: A^{a.self.m} = a.m
+
+def test2(a: A^) =
+  val b: a.type = a
+  val c1: C^{a} = new C(a)
+  val c2: C^{a} = new C(a.m)
+  val c3: C^{a.m} = new C(a.m)
+  val c4: C^{b} = new C(a)
+  val c5: C^{a} = new C(b)
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/singletons.scala b/tests/neg-custom-args/captures/singletons.scala
index 194e6e850dcd..be0ee67ab1bc 100644
--- a/tests/neg-custom-args/captures/singletons.scala
+++ b/tests/neg-custom-args/captures/singletons.scala
@@ -1,6 +1,6 @@
 val x = () => ()
 
-val y1: x.type = x          // ok
-val y2: x.type^{} = x       // error: singleton type cannot have capture set
-val y3: x.type^{x} = x      // error: singleton type cannot have capture set // error
-val y4: x.type^ = x         // error: singleton type cannot have capture set
+val y1: x.type = x
+val y2: x.type^{} = x
+val y3: x.type^{x} = x // error
+val y4: x.type^ = x
diff --git a/tests/pos-custom-args/captures/filevar-expanded.scala b/tests/pos-custom-args/captures/filevar-expanded.scala
index a883471e8d2e..58e7a0e67e0a 100644
--- a/tests/pos-custom-args/captures/filevar-expanded.scala
+++ b/tests/pos-custom-args/captures/filevar-expanded.scala
@@ -1,4 +1,5 @@
 import language.experimental.captureChecking
+import language.experimental.modularity
 import compiletime.uninitialized
 
 object test1:
@@ -22,7 +23,7 @@ object test2:
   class File:
     def write(x: String): Unit = ???
 
-  class Service(io: IO^):
+  class Service(tracked val io: IO^):
     var file: File^{io} = uninitialized
     def log = file.write("log")
 
diff --git a/tests/pos-custom-args/captures/filevar.scala b/tests/pos-custom-args/captures/filevar.scala
index 9ab34fe617b5..dc8d0b18908b 100644
--- a/tests/pos-custom-args/captures/filevar.scala
+++ b/tests/pos-custom-args/captures/filevar.scala
@@ -1,4 +1,5 @@
 import language.experimental.captureChecking
+import language.experimental.modularity
 import compiletime.uninitialized
 
 object test1:
@@ -22,7 +23,7 @@ object test2:
   class File:
     def write(x: String): Unit = ???
 
-  class Service(io: IO):
+  class Service(tracked val io: IO):
     var file: File^{io} = uninitialized
     def log = file.write("log")
 

From 57dd0304822385d987fc780b5f86874161bcc722 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Thu, 19 Sep 2024 15:30:57 +0200
Subject: [PATCH 074/306] Add comment for path-dependent limitation

---
 compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala | 5 +----
 compiler/src/dotty/tools/dotc/cc/Setup.scala         | 5 +++++
 tests/neg-custom-args/captures/path-connection.scala | 2 ++
 3 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index ec1e63137311..b3a1ab44d6cd 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -494,10 +494,7 @@ class CheckCaptures extends Recheck, SymTransformer:
 
       val selType = recheckSelection(tree, qualType, name, disambiguate)
       val selWiden = selType.widen
-      def isStableSel = selType match
-        case selType: NamedType => selType.symbol.isStableMember
-        case _ => false
-        
+
       if pt == LhsProto
           || qualType.isBoxedCapturing
           || selType.isTrackableRef
diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index 22e7899eeea1..76ae41649517 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -518,6 +518,11 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           info match
             case mt: MethodOrPoly =>
               val psyms = psymss.head
+              // TODO: the substitution does not work for param-dependent method types.
+              // For example, `(x: T, y: x.f.type) => Unit`. In this case, when we
+              // substitute `x.f.type`, `x` becomes a `TermParamRef`. But the new method
+              // type is still under initialization and `paramInfos` is still `null`,
+              // so the new `NamedType` will not have a denoation.
               mt.companion(mt.paramNames)(
                 mt1 =>
                   if !paramSignatureChanges && !mt.isParamDependent && prevLambdas.isEmpty then
diff --git a/tests/neg-custom-args/captures/path-connection.scala b/tests/neg-custom-args/captures/path-connection.scala
index 3b3820488c8d..c65aa75b1ed2 100644
--- a/tests/neg-custom-args/captures/path-connection.scala
+++ b/tests/neg-custom-args/captures/path-connection.scala
@@ -19,6 +19,8 @@ class ReaderProxy(tracked val r: Reader^) extends Reader:
 class SenderProxy(tracked val s: Sender^) extends Sender:
   def send(msg: String) = s.send("(Proxy) " + msg)
 
+// TODO: We have to put `c` in the different argument list to make it work.
+// See the comments in `integrateRT`.
 def testConnection(c: Connection^)(
     handle1: Reader^{c.readOnly} => String,
     handle2: Sender^{c} => Unit,

From 2f9f4c4be97d64683a4154c3d4f6fb306f8d373c Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 24 Sep 2024 18:05:57 +0200
Subject: [PATCH 075/306] Add alternative subsumes implementations

This is done for comparing old with new
---
 .../src/dotty/tools/dotc/cc/CaptureRef.scala  | 46 +++++++++++++++++--
 1 file changed, 41 insertions(+), 5 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
index 05162907b608..107b1a178069 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
@@ -93,23 +93,59 @@ trait CaptureRef extends TypeProxy, ValueType:
   final def invalidateCaches() =
     myCaptureSetRunId = NoRunId
 
+  final def subsumes(y: CaptureRef)(using Context): Boolean =
+    val was = subsumesOld(y)
+    val now = subsumesNew(y)
+    if was != now then
+      println(i"diff for  $this subsumes $y, now: $now, ${this.getClass}, ${y.getClass}")
+    was
+
+  final def subsumesOld(y: CaptureRef)(using Context): Boolean =
+    (this eq y)
+    || this.isRootCapability
+    || y.match
+        case y: TermRef =>
+            y.prefix.match
+              case ypre: CaptureRef =>
+                this.subsumesOld(ypre)
+                || this.match
+                    case x @ TermRef(xpre: CaptureRef, _) =>
+                      x.symbol == y.symbol && xpre =:= ypre
+                    case _ =>
+                      false
+              case _ => false
+          || y.info.match
+              case y1: SingletonCaptureRef => this.subsumesOld(y1)
+              case _ => false
+        case MaybeCapability(y1) => this.stripMaybe.subsumesOld(y1)
+        case _ => false
+    || this.match
+        case ReachCapability(x1) => x1.subsumesOld(y.stripReach)
+        case x: TermRef =>
+          x.info match
+            case x1: SingletonCaptureRef => x1.subsumesOld(y)
+            case _ => false
+        case x: TermParamRef => subsumesExistentially(x, y)
+        case x: TypeRef => assumedContainsOf(x).contains(y)
+        case _ => false
+
   /** x subsumes x
    *   this subsumes this.f
    *   x subsumes y  ==>  x* subsumes y, x subsumes y?
    *   x subsumes y  ==>  x* subsumes y*, x? subsumes y?
    *   x: x1.type /\ x1 subsumes y  ==>  x subsumes y
    */
-  final def subsumes(y: CaptureRef)(using Context): Boolean =
+  final def subsumesNew(y: CaptureRef)(using Context): Boolean =
     def compareCaptureRefs(x: Type, y: Type): Boolean =
       (x eq y)
       || y.match
           case y: CaptureRef => x.match
-            case x: CaptureRef => x.subsumes(y)
+            case x: CaptureRef => x.subsumesNew(y)
             case _ => false
           case _ => false
 
     def compareUndelying(x: Type): Boolean = x match
-      case x: SingletonCaptureRef => x.subsumes(y)
+      case x: SingletonCaptureRef => x.subsumesNew(y)
       case x: AndType => compareUndelying(x.tp1) || compareUndelying(x.tp2)
       case x: OrType => compareUndelying(x.tp1) && compareUndelying(x.tp2)
       case _ => false
@@ -140,11 +176,11 @@ trait CaptureRef extends TypeProxy, ValueType:
         if compareCaptureRefs(this, y.prefix) then return true
         // underlying
         if compareCaptureRefs(this, y.info) then return true
-      case MaybeCapability(y1) => return this.stripMaybe.subsumes(y1)
+      case MaybeCapability(y1) => return this.stripMaybe.subsumesNew(y1)
       case _ =>
 
     return this.match
-      case ReachCapability(x1) => x1.subsumes(y.stripReach)
+      case ReachCapability(x1) => x1.subsumesNew(y.stripReach)
       case x: TermRef => compareUndelying(x.info)
       case CapturingType(x1, _) => compareUndelying(x1)
       case x: TermParamRef => subsumesExistentially(x, y)

From 0c50a31003a9090d4e131ee6654be5a5e033433e Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 24 Sep 2024 18:07:50 +0200
Subject: [PATCH 076/306] Revert to previous subsumes scheme

Add the path cases without changing the whole logic
---
 .../src/dotty/tools/dotc/cc/CaptureRef.scala  | 82 +++----------------
 1 file changed, 12 insertions(+), 70 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
index 107b1a178069..195f07f778eb 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
@@ -93,21 +93,21 @@ trait CaptureRef extends TypeProxy, ValueType:
   final def invalidateCaches() =
     myCaptureSetRunId = NoRunId
 
+  /** x subsumes x
+   *   this subsumes this.f
+   *   x subsumes y  ==>  x* subsumes y, x subsumes y?
+   *   x subsumes y  ==>  x* subsumes y*, x? subsumes y?
+   *   x: x1.type /\ x1 subsumes y  ==>  x subsumes y
+   *   TODO: Document path cases
+   */
   final def subsumes(y: CaptureRef)(using Context): Boolean =
-    val was = subsumesOld(y)
-    val now = subsumesNew(y)
-    if was != now then
-      println(i"diff for  $this subsumes $y, now: $now, ${this.getClass}, ${y.getClass}")
-    was
-
-  final def subsumesOld(y: CaptureRef)(using Context): Boolean =
     (this eq y)
     || this.isRootCapability
     || y.match
         case y: TermRef =>
             y.prefix.match
               case ypre: CaptureRef =>
-                this.subsumesOld(ypre)
+                this.subsumes(ypre)
                 || this.match
                     case x @ TermRef(xpre: CaptureRef, _) =>
                       x.symbol == y.symbol && xpre =:= ypre
@@ -115,78 +115,20 @@ trait CaptureRef extends TypeProxy, ValueType:
                       false
               case _ => false
           || y.info.match
-              case y1: SingletonCaptureRef => this.subsumesOld(y1)
+              case y1: SingletonCaptureRef => this.subsumes(y1)
               case _ => false
-        case MaybeCapability(y1) => this.stripMaybe.subsumesOld(y1)
+        case MaybeCapability(y1) => this.stripMaybe.subsumes(y1)
         case _ => false
     || this.match
-        case ReachCapability(x1) => x1.subsumesOld(y.stripReach)
+        case ReachCapability(x1) => x1.subsumes(y.stripReach)
         case x: TermRef =>
           x.info match
-            case x1: SingletonCaptureRef => x1.subsumesOld(y)
+            case x1: SingletonCaptureRef => x1.subsumes(y)
             case _ => false
         case x: TermParamRef => subsumesExistentially(x, y)
         case x: TypeRef => assumedContainsOf(x).contains(y)
         case _ => false
 
-  /** x subsumes x
-   *   this subsumes this.f
-   *   x subsumes y  ==>  x* subsumes y, x subsumes y?
-   *   x subsumes y  ==>  x* subsumes y*, x? subsumes y?
-   *   x: x1.type /\ x1 subsumes y  ==>  x subsumes y
-   */
-  final def subsumesNew(y: CaptureRef)(using Context): Boolean =
-    def compareCaptureRefs(x: Type, y: Type): Boolean =
-      (x eq y)
-      || y.match
-          case y: CaptureRef => x.match
-            case x: CaptureRef => x.subsumesNew(y)
-            case _ => false
-          case _ => false
-
-    def compareUndelying(x: Type): Boolean = x match
-      case x: SingletonCaptureRef => x.subsumesNew(y)
-      case x: AndType => compareUndelying(x.tp1) || compareUndelying(x.tp2)
-      case x: OrType => compareUndelying(x.tp1) && compareUndelying(x.tp2)
-      case _ => false
-
-    if (this eq y) || this.isRootCapability then return true
-
-    // similar to compareNamed in TypeComparer
-    y match
-      case y: TermRef =>
-        this match
-          case x: TermRef =>
-            val xSym = x.symbol
-            val ySym = y.symbol
-
-            // check x.f and y.f
-            if (xSym ne NoSymbol)
-                && (xSym eq ySym)
-                && compareCaptureRefs(x.prefix, y.prefix)
-              || (x.name eq y.name)
-                && x.isPrefixDependentMemberRef
-                && compareCaptureRefs(x.prefix, y.prefix)
-                && x.signature == y.signature
-                && !(xSym.isClass && ySym.isClass)
-            then return true
-          case _ =>
-
-        // shorten
-        if compareCaptureRefs(this, y.prefix) then return true
-        // underlying
-        if compareCaptureRefs(this, y.info) then return true
-      case MaybeCapability(y1) => return this.stripMaybe.subsumesNew(y1)
-      case _ =>
-
-    return this.match
-      case ReachCapability(x1) => x1.subsumesNew(y.stripReach)
-      case x: TermRef => compareUndelying(x.info)
-      case CapturingType(x1, _) => compareUndelying(x1)
-      case x: TermParamRef => subsumesExistentially(x, y)
-      case x: TypeRef => assumedContainsOf(x).contains(y)
-      case _ => false
-
   def assumedContainsOf(x: TypeRef)(using Context): SimpleIdentitySet[CaptureRef] =
     CaptureSet.assumedContains.getOrElse(x, SimpleIdentitySet.empty)
 

From 54c02426699b8095165f3f3df0bfa6dfa0375b1f Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Wed, 25 Sep 2024 11:57:39 +0200
Subject: [PATCH 077/306] Add logic to mark paths as used

If we refer to a path `a.b`, we should mark `a.b` as used,
which is better than marking `a`.
---
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 27 +++++++++++++------
 .../dotty/tools/dotc/transform/Recheck.scala  | 15 +++++------
 .../dotty/tools/dotc/typer/ProtoTypes.scala   |  6 +++--
 tests/pos-custom-args/captures/path-use.scala | 19 +++++++++++++
 4 files changed, 49 insertions(+), 18 deletions(-)
 create mode 100644 tests/pos-custom-args/captures/path-use.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index b3a1ab44d6cd..05bcecf86067 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -13,7 +13,7 @@ import Trees.*
 import typer.RefChecks.{checkAllOverrides, checkSelfAgainstParents, OverridingPairsChecker}
 import typer.Checking.{checkBounds, checkAppliedTypesIn}
 import typer.ErrorReporting.{Addenda, NothingToAdd, err}
-import typer.ProtoTypes.{AnySelectionProto, LhsProto}
+import typer.ProtoTypes.{LhsProto, WildcardSelectionProto}
 import util.{SimpleIdentitySet, EqHashMap, EqHashSet, SrcPos, Property}
 import transform.{Recheck, PreRecheck, CapturedVars}
 import Recheck.*
@@ -183,6 +183,9 @@ object CheckCaptures:
   /** Attachment key for bodies of closures, provided they are values */
   val ClosureBodyValue = Property.Key[Unit]
 
+  /** A prototype that indicates selection with an immutable value */
+  class PathSelectionProto(val sym: Symbol, val pt: Type)(using Context) extends WildcardSelectionProto
+
 class CheckCaptures extends Recheck, SymTransformer:
   thisPhase =>
 
@@ -357,12 +360,13 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  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, provenance(env))
+      markFree(sym, sym.termRef, pos)
+
+    def markFree(sym: Symbol, ref: TermRef, pos: SrcPos)(using Context): Unit =
+      if sym.exists && 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, provenance(env))
 
     /** 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
@@ -464,9 +468,16 @@ class CheckCaptures extends Recheck, SymTransformer:
           includeCallCaptures(tree.symbol, tree.srcPos)
       else
         //debugShowEnvs()
-        markFree(tree.symbol, tree.srcPos)
+        def addSelects(ref: TermRef, pt: Type): TermRef = pt match
+          case pt: PathSelectionProto => addSelects(ref.select(pt.sym).asInstanceOf[TermRef], pt.pt)
+          case _ => ref
+        markFree(tree.symbol, addSelects(tree.symbol.termRef, pt), tree.srcPos)
       super.recheckIdent(tree, pt)
 
+    override def selectionProto(tree: Select, pt: Type)(using Context): Type =
+      if !tree.symbol.isOneOf(UnstableValueFlags) then PathSelectionProto(tree.symbol, pt)
+      else super.selectionProto(tree, pt)
+
     /** A specialized implementation of the selection rule.
      *
      *  E |- f: T{ m: R^Cr }^{f}
diff --git a/compiler/src/dotty/tools/dotc/transform/Recheck.scala b/compiler/src/dotty/tools/dotc/transform/Recheck.scala
index 7520767c918c..8df9e5966920 100644
--- a/compiler/src/dotty/tools/dotc/transform/Recheck.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Recheck.scala
@@ -12,7 +12,7 @@ import DenotTransformers.{DenotTransformer, IdentityDenotTransformer, SymTransfo
 import NamerOps.linkConstructorParams
 import NullOpsDecorator.stripNull
 import typer.ErrorReporting.err
-import typer.ProtoTypes.*
+import typer.ProtoTypes.{AnySelectionProto, LhsProto}
 import typer.TypeAssigner.seqLitType
 import typer.ConstFold
 import typer.ErrorReporting.{Addenda, NothingToAdd}
@@ -206,13 +206,12 @@ abstract class Recheck extends Phase, SymTransformer:
       tree.tpe
 
     def recheckSelect(tree: Select, pt: Type)(using Context): Type =
-      recheckSelection(tree, recheckSelectQualifier(tree), tree.name, pt)
+      recheckSelection(tree,
+        recheck(tree.qualifier, selectionProto(tree, pt)).widenIfUnstable,
+        tree.name, pt)
 
-    def recheckSelectQualifier(tree: Select)(using Context): Type =
-      val proto =
-        if tree.symbol == defn.Any_asInstanceOf then WildcardType
-        else AnySelectionProto
-      recheck(tree.qualifier, proto).widenIfUnstable
+    def selectionProto(tree: Select, pt: Type)(using Context): Type =
+      if tree.symbol == defn.Any_asInstanceOf then WildcardType else AnySelectionProto
 
     def recheckSelection(tree: Select, qualType: Type, name: Name,
         sharpen: Denotation => Denotation)(using Context): Type =
@@ -311,7 +310,7 @@ abstract class Recheck extends Phase, SymTransformer:
     def recheckApply(tree: Apply, pt: Type)(using Context): Type =
       val (funtpe0, qualType) = tree.fun match
         case fun: Select =>
-          val qualType = recheckSelectQualifier(fun)
+          val qualType = recheck(fun.qualifier, selectionProto(fun, WildcardType)).widenIfUnstable
           (recheckSelection(fun, qualType, fun.name, WildcardType), qualType)
         case _ =>
           (recheck(tree.fun), NoType)
diff --git a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
index a69a63d1ceef..53e0b456ed9a 100644
--- a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -324,6 +324,8 @@ object ProtoTypes {
       case tp: UnapplyFunProto => new UnapplySelectionProto(name, nameSpan)
       case tp => SelectionProto(name, IgnoredProto(tp), typer, privateOK = true, nameSpan)
 
+  class WildcardSelectionProto extends SelectionProto(nme.WILDCARD, WildcardType, NoViewsAllowed, true, NoSpan)
+
   /** A prototype for expressions [] that are in some unspecified selection operation
    *
    *    [].?: ?
@@ -332,9 +334,9 @@ object ProtoTypes {
    *  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, NoSpan)
+  @sharable object AnySelectionProto extends WildcardSelectionProto
 
-  @sharable object SingletonTypeProto extends SelectionProto(nme.WILDCARD, WildcardType, NoViewsAllowed, true, NoSpan)
+  @sharable object SingletonTypeProto extends WildcardSelectionProto
 
   /** A prototype for selections in pattern constructors */
   class UnapplySelectionProto(name: Name, nameSpan: Span) extends SelectionProto(name, WildcardType, NoViewsAllowed, true, nameSpan)
diff --git a/tests/pos-custom-args/captures/path-use.scala b/tests/pos-custom-args/captures/path-use.scala
new file mode 100644
index 000000000000..5eb2b60fd218
--- /dev/null
+++ b/tests/pos-custom-args/captures/path-use.scala
@@ -0,0 +1,19 @@
+import language.experimental.namedTuples
+
+class IO
+
+class C(val f: IO^):
+  val procs: List[Proc] = ???
+
+type Proc = () => Unit
+
+def test(io: IO^) =
+  val c = C(io)
+  val f = () => println(c.f)
+  val _: () ->{c.f} Unit = f
+
+  val x = c.procs
+  val _: List[() ->{c.procs*} Unit] = x
+
+  val g = () => println(c.procs.head)
+  val _: () ->{c.procs*} Unit = g

From 3224b2108832f25487e51a51a79c83645b02a8ec Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Wed, 25 Sep 2024 21:01:05 +0200
Subject: [PATCH 078/306] Tweaks to path checking and massage tests

Needed to make stdlib2-cc go through.

There were two errors. One in LayListIterable required a type annotation
and a tweak to markFree. The other in Vieew.scala required a cast, but this could be fixed
with better handling of pattern matching. path-patmat-should-be-pos.scala is a minimization.
---
 .../src/dotty/tools/dotc/cc/CaptureRef.scala  | 27 ++++++++++++-------
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 25 ++++++++++++-----
 .../src/scala/collection/View.scala           |  5 +++-
 .../immutable/LazyListIterable.scala          |  4 ++-
 .../captures/path-patmat-should-be-pos.scala  | 26 ++++++++++++++++++
 5 files changed, 69 insertions(+), 18 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/path-patmat-should-be-pos.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
index 195f07f778eb..bbaf0c7d2fa0 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
@@ -101,6 +101,19 @@ trait CaptureRef extends TypeProxy, ValueType:
    *   TODO: Document path cases
    */
   final def subsumes(y: CaptureRef)(using Context): Boolean =
+
+    def subsumingRefs(x: Type, y: Type): Boolean = x match
+      case x: CaptureRef => y match
+        case y: CaptureRef => x.subsumes(y)
+        case _ => false
+      case _ => false
+
+    def viaInfo(info: Type)(test: Type => Boolean): Boolean = info.match
+      case info: SingletonCaptureRef => test(info)
+      case info: AndType => test(info.tp1) || test(info.tp2)
+      case info: OrType => test(info.tp1) && test(info.tp2)
+      case _ => false
+
     (this eq y)
     || this.isRootCapability
     || y.match
@@ -109,25 +122,21 @@ trait CaptureRef extends TypeProxy, ValueType:
               case ypre: CaptureRef =>
                 this.subsumes(ypre)
                 || this.match
-                    case x @ TermRef(xpre: CaptureRef, _) =>
-                      x.symbol == y.symbol && xpre =:= ypre
+                    case x @ TermRef(xpre: CaptureRef, _) if x.symbol == y.symbol =>
+                      subsumingRefs(xpre, ypre) && subsumingRefs(ypre, xpre)
                     case _ =>
                       false
               case _ => false
-          || y.info.match
-              case y1: SingletonCaptureRef => this.subsumes(y1)
-              case _ => false
+          || viaInfo(y.info)(subsumingRefs(this, _))
         case MaybeCapability(y1) => this.stripMaybe.subsumes(y1)
         case _ => false
     || this.match
         case ReachCapability(x1) => x1.subsumes(y.stripReach)
-        case x: TermRef =>
-          x.info match
-            case x1: SingletonCaptureRef => x1.subsumes(y)
-            case _ => false
+        case x: TermRef => viaInfo(x.info)(subsumingRefs(_, y))
         case x: TermParamRef => subsumesExistentially(x, y)
         case x: TypeRef => assumedContainsOf(x).contains(y)
         case _ => false
+  end subsumes
 
   def assumedContainsOf(x: TypeRef)(using Context): SimpleIdentitySet[CaptureRef] =
     CaptureSet.assumedContains.getOrElse(x, SimpleIdentitySet.empty)
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 05bcecf86067..19acebde8651 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -466,16 +466,24 @@ class CheckCaptures extends Recheck, SymTransformer:
         if tree.symbol.info.isParameterless then
           // there won't be an apply; need to include call captures now
           includeCallCaptures(tree.symbol, tree.srcPos)
-      else
+      else if !tree.symbol.isStatic then
         //debugShowEnvs()
         def addSelects(ref: TermRef, pt: Type): TermRef = pt match
-          case pt: PathSelectionProto => addSelects(ref.select(pt.sym).asInstanceOf[TermRef], pt.pt)
+          case pt: PathSelectionProto if ref.isTracked =>
+            // if `ref` is not tracked then the selection could not give anything new
+            // class SerializationProxy in stdlib-cc/../LazyListIterable.scala has an example where this matters.
+            addSelects(ref.select(pt.sym).asInstanceOf[TermRef], pt.pt)
           case _ => ref
-        markFree(tree.symbol, addSelects(tree.symbol.termRef, pt), tree.srcPos)
+        val ref = tree.symbol.termRef
+        val pathRef = addSelects(ref, pt)
+        //if pathRef ne ref then
+        //  println(i"add selects $ref --> $pathRef")
+        markFree(tree.symbol, if false then ref else pathRef, tree.srcPos)
       super.recheckIdent(tree, pt)
 
     override def selectionProto(tree: Select, pt: Type)(using Context): Type =
-      if !tree.symbol.isOneOf(UnstableValueFlags) then PathSelectionProto(tree.symbol, pt)
+      val sym = tree.symbol
+      if !sym.isOneOf(UnstableValueFlags) && !sym.isStatic then PathSelectionProto(sym, pt)
       else super.selectionProto(tree, pt)
 
     /** A specialized implementation of the selection rule.
@@ -1141,11 +1149,14 @@ class CheckCaptures extends Recheck, SymTransformer:
         (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)
+              def isOuterRef(aref: Type): Boolean = aref match
+                case aref: TermRef =>
+                  val owner = aref.symbol.owner
+                  if owner.isClass then isOuterRef(aref.prefix)
+                  else eref.cls.isProperlyContainedIn(owner)
                 case aref: ThisType => eref.cls.isProperlyContainedIn(aref.cls)
                 case _ => false
-              }
+              erefs ++ arefs.filter(isOuterRef)
             case _ =>
               erefs
 
diff --git a/scala2-library-cc/src/scala/collection/View.scala b/scala2-library-cc/src/scala/collection/View.scala
index 31c544a46beb..132934dbe3bd 100644
--- a/scala2-library-cc/src/scala/collection/View.scala
+++ b/scala2-library-cc/src/scala/collection/View.scala
@@ -150,7 +150,10 @@ object View extends IterableFactory[View] {
   object Filter {
     def apply[A](underlying: Iterable[A]^, p: A => Boolean, isFlipped: Boolean): Filter[A]^{underlying, p} =
       underlying match {
-        case filter: Filter[A] if filter.isFlipped == isFlipped => new Filter(filter.underlying, a => filter.p(a) && p(a), isFlipped)
+        case filter: Filter[A] if filter.isFlipped == isFlipped =>
+          new Filter(filter.underlying, a => filter.p(a) && p(a), isFlipped)
+            .asInstanceOf[Filter[A]^{underlying, p}]
+              // !!! asInstanceOf needed once paths were added, see path-patmat-should-be-pos.scala for minimization
         case _ => new Filter(underlying, p, isFlipped)
       }
   }
diff --git a/scala2-library-cc/src/scala/collection/immutable/LazyListIterable.scala b/scala2-library-cc/src/scala/collection/immutable/LazyListIterable.scala
index 2f7b017a6729..28ce8da104aa 100644
--- a/scala2-library-cc/src/scala/collection/immutable/LazyListIterable.scala
+++ b/scala2-library-cc/src/scala/collection/immutable/LazyListIterable.scala
@@ -1366,7 +1366,9 @@ object LazyListIterable extends IterableFactory[LazyListIterable] {
         case SerializeEnd => initRead = true
         case a => init += a.asInstanceOf[A]
       }
-      val tail = in.readObject().asInstanceOf[LazyListIterable[A]]
+      val tail: LazyListIterable[A] = in.readObject().asInstanceOf[LazyListIterable[A]]
+        // Explicit type annotation needed so that tail.state below is dropped from capture set.
+        // Before paths were added, it was tail that was added, and the `asSeenFrom` to a pure type made it work.
       // scala/scala#10118: caution that no code path can evaluate `tail.state`
       // before the resulting LazyListIterable is returned
       val it = init.toList.iterator
diff --git a/tests/neg-custom-args/captures/path-patmat-should-be-pos.scala b/tests/neg-custom-args/captures/path-patmat-should-be-pos.scala
new file mode 100644
index 000000000000..aca6102204a3
--- /dev/null
+++ b/tests/neg-custom-args/captures/path-patmat-should-be-pos.scala
@@ -0,0 +1,26 @@
+class It[A]
+
+class Filter[A](val underlying: It[A]^, val p: A => Boolean) extends It[A]
+object Filter:
+  def apply[A](underlying: It[A]^, p: A => Boolean): Filter[A]^{underlying, p} =
+    underlying match
+      case filter: Filter[A]^ =>
+        val x = new Filter(filter.underlying, a => filter.p(a) && p(a))
+        x: Filter[A]^{underlying, p} // error
+          // !!! should work, it seems to be the case that the system does not recognize that
+          // underlying and filter are aliases.
+
+    // On the other hand, the following works:
+    locally:
+      val filter: underlying.type & Filter[A] = ???
+      val a: It[A]^{filter.underlying} = ???
+      val b: It[A]^{underlying} = a
+      val x = new Filter(filter.underlying, a => filter.p(a) && p(a))
+      x: Filter[A]^{underlying, p}
+
+    locally:
+      val filter: underlying.type & Filter[A]^ = ???
+      val a: It[A]^{filter.underlying} = ???
+      val b: It[A]^{underlying} = a
+      val x = new Filter(filter.underlying, a => filter.p(a) && p(a))
+      x: Filter[A]^{underlying, p}

From a0c7361669cc60228b097cbbed2bfbdd483f9c05 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Wed, 9 Oct 2024 15:33:11 +0200
Subject: [PATCH 079/306] Update comments for parser; remove unnecessary checks

---
 compiler/src/dotty/tools/dotc/ast/untpd.scala       |  2 +-
 compiler/src/dotty/tools/dotc/cc/CaptureOps.scala   |  3 +--
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala | 12 +++++-------
 3 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index 4684464d477f..e8e3646bd087 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -524,7 +524,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def makeRetaining(parent: Tree, refs: List[Tree], annotName: TypeName)(using Context): Annotated =
     Annotated(parent, New(scalaAnnotationDot(annotName), List(refs)))
 
-  def makeCapsOf(tp: Tree)(using Context): Tree =
+  def makeCapsOf(tp: RefTree)(using Context): Tree =
     TypeApply(Select(scalaDot(nme.caps), nme.capsOf), tp :: Nil)
 
   def makeCapsBound()(using Context): Tree =
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index 79cc7d136e45..aad6ca8ddeac 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -194,8 +194,7 @@ extension (tp: Type)
       true
     case tp: TermRef =>
       ((tp.prefix eq NoPrefix)
-      || tp.symbol.isField && !tp.symbol.isStatic && (
-        tp.prefix.isThisTypeOf(tp.symbol.owner) || tp.prefix.isTrackableRef)
+      || tp.symbol.isField && !tp.symbol.isStatic && tp.prefix.isTrackableRef
       || tp.isRootCapability
       ) && !tp.symbol.isOneOf(UnstableValueFlags)
     case tp: TypeRef =>
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index dc3ae4cf7639..8eb2a7a1e045 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1559,22 +1559,20 @@ object Parsers {
       case _ => None
     }
 
-    /** CaptureRef  ::=  (ident | `this`) [`*` | `^`]
+    /** CaptureRef  ::=  SimpleRef { `.` id } [`*` | `^`]
      */
     def captureRef(): Tree =
-      val ref = singleton()
+      val ref = dotSelectors(simpleRef())
       if isIdent(nme.raw.STAR) then
         in.nextToken()
         atSpan(startOffset(ref)):
           PostfixOp(ref, Ident(nme.CC_REACH))
       else if isIdent(nme.UPARROW) then
         in.nextToken()
-        def toTypeSel(r: Tree): Tree = r match
-          case id: Ident => cpy.Ident(id)(id.name.toTypeName)
-          case Select(qual, id) => Select(qual, id.toTypeName)
-          case _ => r
         atSpan(startOffset(ref)):
-          makeCapsOf(toTypeSel(ref))
+          convertToTypeId(ref) match
+            case ref: RefTree => makeCapsOf(ref)
+            case ref => ref
       else ref
 
     /**  CaptureSet ::=  `{` CaptureRef {`,` CaptureRef} `}`    -- under captureChecking

From d930adf334e1f86ead4b31d212544155a8c2587f Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Wed, 9 Oct 2024 17:00:48 +0200
Subject: [PATCH 080/306] More robust check for subsumes

---
 compiler/src/dotty/tools/dotc/cc/CaptureRef.scala | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
index bbaf0c7d2fa0..61f18008cbad 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
@@ -110,8 +110,8 @@ trait CaptureRef extends TypeProxy, ValueType:
 
     def viaInfo(info: Type)(test: Type => Boolean): Boolean = info.match
       case info: SingletonCaptureRef => test(info)
-      case info: AndType => test(info.tp1) || test(info.tp2)
-      case info: OrType => test(info.tp1) && test(info.tp2)
+      case info: AndType => viaInfo(info.tp1)(test) || viaInfo(info.tp2)(test)
+      case info: OrType => viaInfo(info.tp1)(test) && viaInfo(info.tp2)(test)
       case _ => false
 
     (this eq y)
@@ -123,7 +123,7 @@ trait CaptureRef extends TypeProxy, ValueType:
                 this.subsumes(ypre)
                 || this.match
                     case x @ TermRef(xpre: CaptureRef, _) if x.symbol == y.symbol =>
-                      subsumingRefs(xpre, ypre) && subsumingRefs(ypre, xpre)
+                      withMode(Mode.IgnoreCaptures) {TypeComparer.isSameRef(xpre, ypre)}
                     case _ =>
                       false
               case _ => false

From 5bc20acfe93fb86d0d9557bcfa2166a01c1bb75e Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Wed, 9 Oct 2024 18:29:38 +0200
Subject: [PATCH 081/306] Update syntax comment

---
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 8eb2a7a1e045..aa62b664ba7c 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1559,7 +1559,8 @@ object Parsers {
       case _ => None
     }
 
-    /** CaptureRef  ::=  SimpleRef { `.` id } [`*` | `^`]
+    /** CaptureRef  ::=  { SimpleRef `.` } SimpleRef [`*`]
+     *                |  [ { SimpleRef `.` } SimpleRef `.` ] id `^`
      */
     def captureRef(): Tree =
       val ref = dotSelectors(simpleRef())

From 1b0634a2b8d56e2693ef378f326f250bcab71d1b Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Fri, 27 Sep 2024 19:04:45 +0200
Subject: [PATCH 082/306] Account for added outer refs in the capture sets of
 classes

---
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 45 ++++++++++++++-----
 .../captures/outerRefsUses.scala              | 10 +++++
 2 files changed, 45 insertions(+), 10 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/outerRefsUses.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 19acebde8651..4d905a5df4ab 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -1089,7 +1089,7 @@ class CheckCaptures extends Recheck, SymTransformer:
 
       if actualBoxed eq actual then
         // Only `addOuterRefs` when there is no box adaptation
-        expected1 = addOuterRefs(expected1, actual)
+        expected1 = addOuterRefs(expected1, actual, tree.srcPos)
       if isCompatible(actualBoxed, expected1) then
         if debugSuccesses then tree match
             case Ident(_) =>
@@ -1130,8 +1130,12 @@ class CheckCaptures extends Recheck, SymTransformer:
      *     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.
+     *   - To make up for this, we also add these variables to the capture set of `Cls`,
+     *     so that all instances of `Cls` will capture these outer references.
+     *  So in a sense we use `{Cls.this}` as a placeholder for certain outer captures.
+     *  that we needed to be subsumed by `Cls.this`.
      */
-    private def addOuterRefs(expected: Type, actual: Type)(using Context): Type =
+    private def addOuterRefs(expected: Type, actual: Type, pos: SrcPos)(using Context): Type =
 
       def isPure(info: Type): Boolean = info match
         case info: PolyType => isPure(info.resType)
@@ -1144,19 +1148,40 @@ class CheckCaptures extends Recheck, SymTransformer:
         else isPure(owner.info) && isPureContext(owner.owner, limit)
 
       // Augment expeced capture set `erefs` by all references in actual capture
-      // set `arefs` that are outside some `this.type` reference in `erefs`
+      // set `arefs` that are outside some `C.this.type` reference in `erefs` for an enclosing
+      // class `C`. If an added reference is not a ThisType itself, add it to the capture set
+      // (i.e. use set) of the `C`. This makes sure that any outer reference implicitly subsumed
+      // by `C.this` becomes a capture reference of every instance of `C`.
       def augment(erefs: CaptureSet, arefs: CaptureSet): CaptureSet =
         (erefs /: erefs.elems): (erefs, eref) =>
           eref match
             case eref: ThisType if isPureContext(ctx.owner, eref.cls) =>
-              def isOuterRef(aref: Type): Boolean = aref match
-                case aref: TermRef =>
-                  val owner = aref.symbol.owner
-                  if owner.isClass then isOuterRef(aref.prefix)
-                  else eref.cls.isProperlyContainedIn(owner)
+
+              def pathRoot(aref: Type): Type = aref match
+                case aref: NamedType if aref.symbol.owner.isClass => pathRoot(aref.prefix)
+                case _ => aref
+
+              def isOuterRef(aref: Type): Boolean = pathRoot(aref) match
+                case aref: NamedType => eref.cls.isProperlyContainedIn(aref.symbol.owner)
                 case aref: ThisType => eref.cls.isProperlyContainedIn(aref.cls)
                 case _ => false
-              erefs ++ arefs.filter(isOuterRef)
+
+              val outerRefs = arefs.filter(isOuterRef)
+
+              // Include implicitly added outer references in the capture set of the class of `eref`.
+              for outerRef <- outerRefs.elems do
+                if !erefs.elems.contains(outerRef)
+                    && !pathRoot(outerRef).isInstanceOf[ThisType]
+                    // we don't need to add outer ThisTypes as these are anyway added as path
+                    // prefixes at the use site. And this exemption is required since capture sets
+                    // of non-local classes are always empty, so we can't add an outer this to them.
+                then
+                  def provenance =
+                    i""" of the enclosing class ${eref.cls}.
+                       |The reference was included since we tried to establish that $arefs <: $erefs"""
+                  checkElem(outerRef, capturedVars(eref.cls), pos, provenance)
+
+              erefs ++ outerRefs
             case _ =>
               erefs
 
@@ -1341,7 +1366,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         *  @param sym  symbol of the field definition that is being checked
         */
         override def checkSubType(actual: Type, expected: Type)(using Context): Boolean =
-          val expected1 = alignDependentFunction(addOuterRefs(expected, actual), actual.stripCapturing)
+          val expected1 = alignDependentFunction(addOuterRefs(expected, actual, srcPos), actual.stripCapturing)
           val actual1 =
             val saved = curEnv
             try
diff --git a/tests/neg-custom-args/captures/outerRefsUses.scala b/tests/neg-custom-args/captures/outerRefsUses.scala
new file mode 100644
index 000000000000..cd03c8c41efd
--- /dev/null
+++ b/tests/neg-custom-args/captures/outerRefsUses.scala
@@ -0,0 +1,10 @@
+class IO
+def test(io: IO^) =
+  class C:
+    def foo() = () =>
+      val x: IO^{this} = io
+      ()
+  val c = new C
+  val _: C^{io} = c // ok
+  val _: C = c // error
+  ()

From 4d79459b6cf4b503e81869786ae6024afda5eb3e Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 28 Oct 2024 10:45:08 +0000
Subject: [PATCH 083/306] Fix use of class terms in match analysis

When instantiating a subclass Outer.this.Bar, such that it's a subtype
of Test.this.outer.Foo[X], make sure to infer the term `outer` (even if
it's not a parameter).  Also make sure to use those singletons when
approximating the parent (to fix Outer.this.Qux instantiating).
---
 .../src/dotty/tools/dotc/core/TypeOps.scala   | 131 +++++++++---------
 .../tools/dotc/printing/RefinedPrinter.scala  |   1 +
 tests/warn/i21845.orig.scala                  |  33 +++++
 tests/warn/i21845.scala                       |  15 ++
 4 files changed, 118 insertions(+), 62 deletions(-)
 create mode 100644 tests/warn/i21845.orig.scala
 create mode 100644 tests/warn/i21845.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
index bfda613d0586..fac5d262d426 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -767,6 +767,67 @@ object TypeOps:
    *  Otherwise, return NoType.
    */
   private def instantiateToSubType(tp1: NamedType, tp2: Type, mixins: List[Type])(using Context): Type = trace(i"instantiateToSubType($tp1, $tp2, $mixins)", typr) {
+    /** Gather GADT symbols and singletons found in `tp2`, ie. the scrutinee. */
+    object TraverseTp2 extends TypeTraverser:
+      val singletons = util.HashMap[Symbol, SingletonType]()
+      val gadtSyms = new mutable.ListBuffer[Symbol]
+
+      def traverse(tp: Type) = try
+        val tpd = tp.dealias
+        if tpd ne tp then traverse(tpd)
+        else tp match
+          case tp: ThisType if !singletons.contains(tp.tref.symbol) && !tp.tref.symbol.isStaticOwner =>
+            singletons(tp.tref.symbol) = tp
+            traverseChildren(tp.tref)
+          case tp: TermRef =>
+            singletons(tp.typeSymbol) = tp
+            traverseChildren(tp)
+          case tp: TypeRef if !gadtSyms.contains(tp.symbol) && tp.symbol.isAbstractOrParamType =>
+            gadtSyms += tp.symbol
+            traverseChildren(tp)
+            // traverse abstract type infos, to add any singletons
+            // for example, i16451.CanForward.scala, add `Namer.this`, from the info of the type parameter `A1`
+            // also, i19031.ci-reg2.scala, add `out`, from the info of the type parameter `A1` (from synthetic applyOrElse)
+            traverseChildren(tp.info)
+          case _ =>
+            traverseChildren(tp)
+      catch case ex: Throwable => handleRecursive("traverseTp2", tp.show, ex)
+    TraverseTp2.traverse(tp2)
+    val singletons = TraverseTp2.singletons
+    val gadtSyms   = TraverseTp2.gadtSyms.toList
+
+    // Prefix inference, given `p.C.this.Child`:
+    //   1. return it as is, if `C.this` is found in `tp`, i.e. the scrutinee; or
+    //   2. replace it with `X.Child` where `X <: p.C`, stripping ThisType in `p` recursively.
+    //
+    // See tests/patmat/i3938.scala, tests/pos/i15029.more.scala, tests/pos/i16785.scala
+    class InferPrefixMap extends TypeMap {
+      var prefixTVar: Type | Null = null
+      def apply(tp: Type): Type = tp match {
+        case tp: TermRef if singletons.contains(tp.symbol) =>
+          prefixTVar = singletons(tp.symbol) // e.g. tests/pos/i19031.ci-reg2.scala, keep out
+          prefixTVar.uncheckedNN
+        case ThisType(tref) if !tref.symbol.isStaticOwner =>
+          val symbol = tref.symbol
+          if singletons.contains(symbol) then
+            prefixTVar = singletons(symbol) // e.g. tests/pos/i16785.scala, keep Outer.this
+            prefixTVar.uncheckedNN
+          else if symbol.is(Module) then
+            TermRef(this(tref.prefix), symbol.sourceModule)
+          else if (prefixTVar != null)
+            this(tref.applyIfParameterized(tref.typeParams.map(_ => WildcardType)))
+          else {
+            prefixTVar = WildcardType  // prevent recursive call from assigning it
+            // e.g. tests/pos/i15029.more.scala, create a TypeVar for `Instances`' B, so we can disregard `Ints`
+            val tvars = tref.typeParams.map { tparam => newTypeVar(tparam.paramInfo.bounds, DepParamName.fresh(tparam.paramName)) }
+            val tref2 = this(tref.applyIfParameterized(tvars))
+            prefixTVar = newTypeVar(TypeBounds.upper(tref2), DepParamName.fresh(tref.name))
+            prefixTVar.uncheckedNN
+          }
+        case tp => mapOver(tp)
+      }
+    }
+
     // 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.
     //
@@ -788,8 +849,15 @@ object TypeOps:
                                  // then to avoid it failing the <:<
                                  // we'll approximate by widening to its bounds
 
+        case tp: TermRef if singletons.contains(tp.symbol) =>
+          singletons(tp.symbol)
+
         case ThisType(tref: TypeRef) if !tref.symbol.isStaticOwner =>
-          tref
+          val symbol = tref.symbol
+          if singletons.contains(symbol) then
+            singletons(symbol)
+          else
+            tref
 
         case tp: TypeRef if !tp.symbol.isClass =>
           val lookup = boundTypeParams.lookup(tp)
@@ -840,67 +908,6 @@ object TypeOps:
       }
     }
 
-    /** Gather GADT symbols and singletons found in `tp2`, ie. the scrutinee. */
-    object TraverseTp2 extends TypeTraverser:
-      val singletons = util.HashMap[Symbol, SingletonType]()
-      val gadtSyms = new mutable.ListBuffer[Symbol]
-
-      def traverse(tp: Type) = try
-        val tpd = tp.dealias
-        if tpd ne tp then traverse(tpd)
-        else tp match
-          case tp: ThisType if !singletons.contains(tp.tref.symbol) && !tp.tref.symbol.isStaticOwner =>
-            singletons(tp.tref.symbol) = tp
-            traverseChildren(tp.tref)
-          case tp: TermRef if tp.symbol.is(Param) =>
-            singletons(tp.typeSymbol) = tp
-            traverseChildren(tp)
-          case tp: TypeRef if !gadtSyms.contains(tp.symbol) && tp.symbol.isAbstractOrParamType =>
-            gadtSyms += tp.symbol
-            traverseChildren(tp)
-            // traverse abstract type infos, to add any singletons
-            // for example, i16451.CanForward.scala, add `Namer.this`, from the info of the type parameter `A1`
-            // also, i19031.ci-reg2.scala, add `out`, from the info of the type parameter `A1` (from synthetic applyOrElse)
-            traverseChildren(tp.info)
-          case _ =>
-            traverseChildren(tp)
-      catch case ex: Throwable => handleRecursive("traverseTp2", tp.show, ex)
-    TraverseTp2.traverse(tp2)
-    val singletons = TraverseTp2.singletons
-    val gadtSyms   = TraverseTp2.gadtSyms.toList
-
-    // Prefix inference, given `p.C.this.Child`:
-    //   1. return it as is, if `C.this` is found in `tp`, i.e. the scrutinee; or
-    //   2. replace it with `X.Child` where `X <: p.C`, stripping ThisType in `p` recursively.
-    //
-    // See tests/patmat/i3938.scala, tests/pos/i15029.more.scala, tests/pos/i16785.scala
-    class InferPrefixMap extends TypeMap {
-      var prefixTVar: Type | Null = null
-      def apply(tp: Type): Type = tp match {
-        case tp: TermRef if singletons.contains(tp.symbol) =>
-          prefixTVar = singletons(tp.symbol) // e.g. tests/pos/i19031.ci-reg2.scala, keep out
-          prefixTVar.uncheckedNN
-        case ThisType(tref) if !tref.symbol.isStaticOwner =>
-          val symbol = tref.symbol
-          if singletons.contains(symbol) then
-            prefixTVar = singletons(symbol) // e.g. tests/pos/i16785.scala, keep Outer.this
-            prefixTVar.uncheckedNN
-          else if symbol.is(Module) then
-            TermRef(this(tref.prefix), symbol.sourceModule)
-          else if (prefixTVar != null)
-            this(tref.applyIfParameterized(tref.typeParams.map(_ => WildcardType)))
-          else {
-            prefixTVar = WildcardType  // prevent recursive call from assigning it
-            // e.g. tests/pos/i15029.more.scala, create a TypeVar for `Instances`' B, so we can disregard `Ints`
-            val tvars = tref.typeParams.map { tparam => newTypeVar(tparam.paramInfo.bounds, DepParamName.fresh(tparam.paramName)) }
-            val tref2 = this(tref.applyIfParameterized(tvars))
-            prefixTVar = newTypeVar(TypeBounds.upper(tref2), DepParamName.fresh(tref.name))
-            prefixTVar.uncheckedNN
-          }
-        case tp => mapOver(tp)
-      }
-    }
-
     val inferThisMap = new InferPrefixMap
     val tvars = tp1.typeParams.map { tparam => newTypeVar(tparam.paramInfo.bounds, DepParamName.fresh(tparam.paramName)) }
     val protoTp1 = inferThisMap.apply(tp1).appliedTo(tvars)
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index b229c7ec29d9..f22abbd2efcb 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -1121,6 +1121,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         recur(fn) ~ "(" ~ toTextGlobal(explicitArgs, ", ") ~ ")"
       case TypeApply(fn, args) => recur(fn) ~ "[" ~ toTextGlobal(args, ", ") ~ "]"
       case Select(qual, nme.CONSTRUCTOR) => recur(qual)
+      case id @ Ident(tpnme.BOUNDTYPE_ANNOT) => "@" ~ toText(id.symbol.name)
       case New(tpt) => recur(tpt)
       case _ =>
         val annotSym = sym.orElse(tree.symbol.enclosingClass)
diff --git a/tests/warn/i21845.orig.scala b/tests/warn/i21845.orig.scala
new file mode 100644
index 000000000000..a8e0893ea5ce
--- /dev/null
+++ b/tests/warn/i21845.orig.scala
@@ -0,0 +1,33 @@
+trait Init[ScopeType]:
+  sealed trait Initialize[A1]
+  final class Bind[S, A1](val f: S => Initialize[A1], val in: Initialize[S])
+    extends Initialize[A1]
+  final class Value[A1](val value: () => A1) extends Initialize[A1]
+  final class ValidationCapture[A1](val key: ScopedKey[A1], val selfRefOk: Boolean)
+        extends Initialize[ScopedKey[A1]]
+  final class TransformCapture(val f: [x] => Initialize[x] => Initialize[x])
+        extends Initialize[[x] => Initialize[x] => Initialize[x]]
+  final class Optional[S, A1](val a: Option[Initialize[S]], val f: Option[S] => A1)
+        extends Initialize[A1]
+  object StaticScopes extends Initialize[Set[ScopeType]]
+
+  sealed trait Keyed[S, A1] extends Initialize[A1]
+  trait KeyedInitialize[A1] extends Keyed[A1, A1]
+  sealed case class ScopedKey[A](scope: ScopeType, key: AttributeKey[A]) extends KeyedInitialize[A]
+  sealed trait AttributeKey[A]
+
+abstract class EvaluateSettings[ScopeType]:
+    protected val init: Init[ScopeType]
+    import init._
+
+    val transform: [A] => Initialize[A] => Unit = [A] =>
+        (fa: Initialize[A]) =>
+          fa match
+            case k: Keyed[s, A]          => ???
+            case b: Bind[s, A]           => ???
+            case v: Value[A]             => ???
+            case v: ValidationCapture[a] => ??? // unrearchable warning
+            case t: TransformCapture     => ??? // unrearchable warning
+            case o: Optional[s, A]       => ??? // unrearchable warning
+            case StaticScopes            => ??? // unrearchable warning
+
diff --git a/tests/warn/i21845.scala b/tests/warn/i21845.scala
new file mode 100644
index 000000000000..58590c74e1d4
--- /dev/null
+++ b/tests/warn/i21845.scala
@@ -0,0 +1,15 @@
+trait Outer[O1]:
+  sealed trait Foo[A1]
+  final class Bar[A2] extends Foo[A2]
+  final class Baz[A4] extends Foo[Bar[A4]]
+  final class Qux     extends Foo[[a5] => Foo[a5] => Foo[a5]]
+
+trait Test[O2]:
+  val outer: Outer[O2]
+  import outer.*
+
+  def test[X](fa: Foo[X]): Unit =
+    fa match // was: inexhaustive: fail on _: (Outer[<?>] & (Test#outer : Outer[Test#O2]))#Qux
+      case _: Bar[X] => ???
+      case _: Baz[x] => ??? // was: unrearchable warning
+      case _: Qux    => ??? // was: unrearchable warning

From e7221c672030375a0bd2391befc6e1fb4938693e Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Fri, 25 Oct 2024 10:48:56 +0200
Subject: [PATCH 084/306] fix: Allow `as` as an infix type in non context bound
 types

---
 .../dotty/tools/dotc/parsing/Parsers.scala    | 22 +++++++++++--------
 tests/pos/i21769.scala                        | 19 ++++++++++++++++
 2 files changed, 32 insertions(+), 9 deletions(-)
 create mode 100644 tests/pos/i21769.scala

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 47391a4114cf..1a5b270f2a48 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -80,6 +80,9 @@ object Parsers {
   enum IntoOK:
     case Yes, No, Nested
 
+  enum InContextBound:
+    case Yes, No
+
   type StageKind = Int
   object StageKind {
     val None = 0
@@ -1550,7 +1553,8 @@ object Parsers {
     /** 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(intoOK: IntoOK = IntoOK.No): Tree = rejectWildcardType(typ(intoOK))
+    def toplevelTyp(intoOK: IntoOK = IntoOK.No, inContextBound: InContextBound = InContextBound.No): Tree =
+      rejectWildcardType(typ(intoOK, inContextBound))
 
     private def getFunction(tree: Tree): Option[Function] = tree match {
       case Parens(tree1) => getFunction(tree1)
@@ -1605,7 +1609,7 @@ object Parsers {
      *  IntoTargetType ::=  Type
      *                   |  FunTypeArgs (‘=>’ | ‘?=>’) IntoType
      */
-    def typ(intoOK: IntoOK = IntoOK.No): Tree =
+    def typ(intoOK: IntoOK = IntoOK.No, inContextBound: InContextBound = InContextBound.No): Tree =
       val start = in.offset
       var imods = Modifiers()
       val erasedArgs: ListBuffer[Boolean] = ListBuffer()
@@ -1754,7 +1758,7 @@ object Parsers {
             val tuple = atSpan(start):
               makeTupleOrParens(args.mapConserve(convertToElem))
             typeRest:
-              infixTypeRest:
+              infixTypeRest(inContextBound):
                 refinedTypeRest:
                   withTypeRest:
                     annotTypeRest:
@@ -1777,7 +1781,7 @@ object Parsers {
       else if isIntoPrefix then
         PrefixOp(typeIdent(), typ(IntoOK.Nested))
       else
-        typeRest(infixType())
+        typeRest(infixType(inContextBound))
     end typ
 
     private def makeKindProjectorTypeDef(name: TypeName): TypeDef = {
@@ -1832,13 +1836,13 @@ object Parsers {
     /** InfixType ::= RefinedType {id [nl] RefinedType}
      *             |  RefinedType `^`   // under capture checking
      */
-    def infixType(): Tree = infixTypeRest(refinedType())
+    def infixType(inContextBound: InContextBound = InContextBound.No): Tree = infixTypeRest(inContextBound)(refinedType())
 
-    def infixTypeRest(t: Tree, operand: Location => Tree = refinedTypeFn): Tree =
+    def infixTypeRest(inContextBound: InContextBound = InContextBound.No)(t: Tree, operand: Location => Tree = refinedTypeFn): Tree =
       infixOps(t, canStartInfixTypeTokens, operand, Location.ElseWhere, ParseKind.Type,
         isOperator = !followingIsVararg()
                      && !isPureArrow
-                     && !(isIdent(nme.as) && sourceVersion.isAtLeast(`3.6`))
+                     && !(isIdent(nme.as) && sourceVersion.isAtLeast(`3.6`) && inContextBound == InContextBound.Yes)
                      && nextCanFollowOperator(canStartInfixTypeTokens))
 
     /** RefinedType   ::=  WithType {[nl] Refinement} [`^` CaptureSet]
@@ -2229,7 +2233,7 @@ object Parsers {
 
     /** ContextBound      ::=  Type [`as` id] */
     def contextBound(pname: TypeName): Tree =
-      val t = toplevelTyp()
+      val t = toplevelTyp(inContextBound = InContextBound.Yes)
       val ownName =
         if isIdent(nme.as) && sourceVersion.isAtLeast(`3.6`) then
           in.nextToken()
@@ -4207,7 +4211,7 @@ object Parsers {
         else constrApp() match
           case parent: Apply => parent :: moreConstrApps()
           case parent if in.isIdent && newSyntaxAllowed =>
-            infixTypeRest(parent, _ => annotType1()) :: Nil
+            infixTypeRest()(parent, _ => annotType1()) :: Nil
           case parent => parent :: moreConstrApps()
 
       // The term parameters and parent references */
diff --git a/tests/pos/i21769.scala b/tests/pos/i21769.scala
new file mode 100644
index 000000000000..afb1c66c97fe
--- /dev/null
+++ b/tests/pos/i21769.scala
@@ -0,0 +1,19 @@
+
+infix trait as[From, To]
+
+val conv: (String as Int) = ???
+given instance: (String as Int) = ???
+def test(ev: (String as Int)) = ???
+
+class F
+
+class K extends (F as K)
+
+class TC1[X]
+
+def doSth[X: TC1 as tc] = ???
+
+class TC2[X]:
+  type Self = X
+
+def doSth2[X: {TC1 as tc1, TC2 as tc2}](x: tc2.Self) = ???

From cb9fcd88ac63eed06a16fe9f85deac2fc29b17eb Mon Sep 17 00:00:00 2001
From: HarrisL2 <harris.yh.lau@gmail.com>
Date: Mon, 28 Oct 2024 11:31:55 -0400
Subject: [PATCH 085/306] Add comment

---
 compiler/src/dotty/tools/dotc/transform/patmat/Space.scala | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index c7b304e6caf6..c7f7a236fcf3 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -941,6 +941,7 @@ object SpaceEngine {
               val msg = if nullOnly then MatchCaseOnlyNullWarning() else MatchCaseUnreachable()
               report.warning(msg, pat.srcPos)
 
+            // in redundancy check, take guard as false in order to soundly approximate
             val newPrev = if guard.isEmpty then covered :: prevs else prevs
             recur(rest, newPrev, Nil)
 

From 03ee583d39b9fd0ae85f6d2477dc21b232cd2d06 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 28 Oct 2024 22:05:56 +0100
Subject: [PATCH 086/306] Make sure definition tree has the defined symbol

It turns out it could have the wrong symbol referring to a same-named definition
in the superclass under some recursive definition of a self type. This caused a crash
in pickler in #21755 because we now have two different definitions in two different classes that
have the same symbol.

Fixes #21755
---
 compiler/src/dotty/tools/dotc/ast/tpd.scala      | 16 ++++++++++++++++
 .../tools/dotc/core/tasty/TreeUnpickler.scala    |  1 +
 compiler/src/dotty/tools/dotc/typer/Typer.scala  |  9 ++++++---
 tests/pos/i21755.scala                           | 11 +++++++++++
 4 files changed, 34 insertions(+), 3 deletions(-)
 create mode 100644 tests/pos/i21755.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index f97baa7f7889..3777969b1076 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -11,6 +11,7 @@ import Symbols.*, StdNames.*, Annotations.*, Trees.*, Symbols.*
 import Decorators.*, DenotTransformers.*
 import collection.{immutable, mutable}
 import util.{Property, SourceFile}
+import config.Printers.typr
 import NameKinds.{TempResultName, OuterSelectName}
 import typer.ConstFold
 
@@ -1165,6 +1166,21 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       tree
     }
 
+    /** Make sure tree has given symbol. This is called when typing or unpickling
+     *  a ValDef or DefDef. It turns out that under very rare circumstances the symbol
+     *  computed for a tree is not correct. The only known test case is i21755.scala.
+     *  Here we have a self type that mentions a supertype as well as a type parameter
+     *  upper-bounded by the current class and it turns out that we compute the symbol
+     *  for a member method (named `root` in this case) in a subclass to be the
+     *  corresponding symbol in the superclass. It is not known what are the precise
+     *  conditions where this happens, but my guess would be that it's connected to the
+     *  recursion in the self type.
+     */
+    def ensureHasSym(sym: Symbol)(using Context): Unit =
+      if sym.exists && sym != tree.symbol then
+        typr.println(i"correcting definition symbol from ${tree.symbol.showLocated} to ${sym.showLocated}")
+        tree.overwriteType(NamedType(sym.owner.thisType, sym.asTerm.name, sym.denot))
+
     def etaExpandCFT(using Context): Tree =
       def expand(target: Tree, tp: Type)(using Context): Tree = tp match
         case defn.ContextFunctionType(argTypes, resType) =>
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index e62db9af520a..b401de823c6c 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -999,6 +999,7 @@ class TreeUnpickler(reader: TastyReader,
         }
       }
 
+      tree.ensureHasSym(sym)
       tree.setDefTree
     }
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 3810bc66841e..e2a07d3832ab 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2949,19 +2949,22 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val ddef2 = assignType(cpy.DefDef(ddef)(name, paramss1, tpt1, rhs1), sym)
 
     postProcessInfo(ddef2, sym)
-    ddef2.setDefTree
-      //todo: make sure dependent method types do not depend on implicits or by-name params
+    //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
    *  (3) Check that erased classes are not parameters of polymorphic functions.
+   *  (4) Make sure the definition's symbol is `sym`.
+   *  (5) Set the `defTree` of `sym` to be `mdef`.
    */
-  private def postProcessInfo(mdef: MemberDef, sym: Symbol)(using Context): Unit =
+  private def postProcessInfo(mdef: MemberDef, sym: Symbol)(using Context): MemberDef =
     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)
+    mdef.ensureHasSym(sym)
+    mdef.setDefTree
 
   def typedTypeDef(tdef: untpd.TypeDef, sym: Symbol)(using Context): Tree = ctx.profiler.onTypedDef(sym) {
     val TypeDef(name, rhs) = tdef
diff --git a/tests/pos/i21755.scala b/tests/pos/i21755.scala
new file mode 100644
index 000000000000..170daed04f05
--- /dev/null
+++ b/tests/pos/i21755.scala
@@ -0,0 +1,11 @@
+trait GraphTraversal  {
+  type NodeT
+
+  protected trait Properties {
+    def root: NodeT
+  }
+
+  abstract protected class TraverserMethods[A, +CC <: TraverserMethods[A, CC]]  { this: CC with Properties =>
+    def root: NodeT
+  }
+}
\ No newline at end of file

From 39d45dc82df20306bdd32ee4ea72f494c6ab6ff1 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Tue, 29 Oct 2024 10:31:49 +0100
Subject: [PATCH 087/306] Add missing error messages to asserts in QuotesImpl

---
 .../scala/quoted/runtime/impl/QuotesImpl.scala |  4 ++--
 tests/neg/i20946.check                         | 18 ++++++++++++++++++
 tests/neg/i20946/Macro_1.scala                 | 10 ++++++++++
 tests/neg/i20946/Test_2.scala                  |  6 ++++++
 tests/neg/i20946a.check                        | 18 ++++++++++++++++++
 tests/neg/i20946a/Macro_1.scala                | 10 ++++++++++
 tests/neg/i20946a/Test_2.scala                 |  6 ++++++
 7 files changed, 70 insertions(+), 2 deletions(-)
 create mode 100644 tests/neg/i20946.check
 create mode 100644 tests/neg/i20946/Macro_1.scala
 create mode 100644 tests/neg/i20946/Test_2.scala
 create mode 100644 tests/neg/i20946a.check
 create mode 100644 tests/neg/i20946a/Macro_1.scala
 create mode 100644 tests/neg/i20946a/Test_2.scala

diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index e8524a193e5a..abda4aa191a9 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -472,7 +472,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def term(tp: TermRef): Ref =
         withDefaultPos(tpd.ref(tp).asInstanceOf[tpd.RefTree])
       def apply(sym: Symbol): Ref =
-        assert(sym.isTerm)
+        assert(sym.isTerm, s"expected a term symbol but received $sym")
         val refTree = tpd.ref(sym) match
           case t @ tpd.This(ident) => // not a RefTree, so we need to work around this - issue #19732
             // ident in `This` can be a TypeIdent of sym, so we manually prepare the ref here,
@@ -1162,7 +1162,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     object TypeIdent extends TypeIdentModule:
       def apply(sym: Symbol): TypeTree =
-        assert(sym.isType)
+        assert(sym.isType, s"Expected a type symbol, but got $sym")
         withDefaultPos(tpd.ref(sym).asInstanceOf[tpd.TypeTree])
       def copy(original: Tree)(name: String): TypeIdent =
         tpd.cpy.Ident(original)(name.toTypeName)
diff --git a/tests/neg/i20946.check b/tests/neg/i20946.check
new file mode 100644
index 000000000000..acce8bf4852d
--- /dev/null
+++ b/tests/neg/i20946.check
@@ -0,0 +1,18 @@
+
+-- Error: tests/neg/i20946/Test_2.scala:5:29 ---------------------------------------------------------------------------
+5 |  macroWithAssertFailing[Int](123) // error
+  |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |  Exception occurred while executing macro expansion.
+  |  java.lang.AssertionError: assertion failed: expected a term symbol but received class Int
+  |  	at scala.runtime.Scala3RunTime$.assertFailed(Scala3RunTime.scala:8)
+  |  	at scala.quoted.runtime.impl.QuotesImpl$reflect$Ref$.apply(QuotesImpl.scala:475)
+  |  	at scala.quoted.runtime.impl.QuotesImpl$reflect$Ref$.apply(QuotesImpl.scala:474)
+  |  	at Macro_1$package$.macroWithAssertFailingImpl(Macro_1.scala:6)
+  |
+  |---------------------------------------------------------------------------------------------------------------------
+  |Inline stack trace
+  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  |This location contains code that was inlined from Test_2.scala:1
+1 |inline def macroWithAssertFailing[T](t: T): Unit = ${ macroWithAssertFailingImpl[T]('t) }
+  |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   ---------------------------------------------------------------------------------------------------------------------
diff --git a/tests/neg/i20946/Macro_1.scala b/tests/neg/i20946/Macro_1.scala
new file mode 100644
index 000000000000..0f2bb8416a0c
--- /dev/null
+++ b/tests/neg/i20946/Macro_1.scala
@@ -0,0 +1,10 @@
+import scala.quoted.*
+
+def macroWithAssertFailingImpl[T: Type](t: Expr[T])(using Quotes): Expr[Unit] = {
+  import quotes.reflect.*
+
+  Ref(TypeRepr.of[T].typeSymbol)
+
+  '{()}
+}
+
diff --git a/tests/neg/i20946/Test_2.scala b/tests/neg/i20946/Test_2.scala
new file mode 100644
index 000000000000..79a02ff1a5db
--- /dev/null
+++ b/tests/neg/i20946/Test_2.scala
@@ -0,0 +1,6 @@
+inline def macroWithAssertFailing[T](t: T): Unit = ${ macroWithAssertFailingImpl[T]('t) }
+
+@main
+def run =
+  macroWithAssertFailing[Int](123) // error
+
diff --git a/tests/neg/i20946a.check b/tests/neg/i20946a.check
new file mode 100644
index 000000000000..f279a60a4798
--- /dev/null
+++ b/tests/neg/i20946a.check
@@ -0,0 +1,18 @@
+
+-- Error: tests/neg/i20946a/Test_2.scala:5:29 --------------------------------------------------------------------------
+5 |  macroWithAssertFailing[Int](123) // error
+  |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |  Exception occurred while executing macro expansion.
+  |  java.lang.AssertionError: assertion failed: Expected a type symbol, but got val <none>
+  |  	at scala.runtime.Scala3RunTime$.assertFailed(Scala3RunTime.scala:8)
+  |  	at scala.quoted.runtime.impl.QuotesImpl$reflect$TypeIdent$.apply(QuotesImpl.scala:1165)
+  |  	at scala.quoted.runtime.impl.QuotesImpl$reflect$TypeIdent$.apply(QuotesImpl.scala:1164)
+  |  	at Macro_1$package$.macroWithAssertFailingImpl(Macro_1.scala:6)
+  |
+  |---------------------------------------------------------------------------------------------------------------------
+  |Inline stack trace
+  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  |This location contains code that was inlined from Test_2.scala:1
+1 |inline def macroWithAssertFailing[T](t: T): Unit = ${ macroWithAssertFailingImpl[T]('t) }
+  |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   ---------------------------------------------------------------------------------------------------------------------
diff --git a/tests/neg/i20946a/Macro_1.scala b/tests/neg/i20946a/Macro_1.scala
new file mode 100644
index 000000000000..c0e9e6eec116
--- /dev/null
+++ b/tests/neg/i20946a/Macro_1.scala
@@ -0,0 +1,10 @@
+import scala.quoted.*
+
+def macroWithAssertFailingImpl[T: Type](t: Expr[T])(using Quotes): Expr[Unit] = {
+  import quotes.reflect.*
+
+  TypeIdent(t.asTerm.symbol)
+
+  '{()}
+}
+
diff --git a/tests/neg/i20946a/Test_2.scala b/tests/neg/i20946a/Test_2.scala
new file mode 100644
index 000000000000..79a02ff1a5db
--- /dev/null
+++ b/tests/neg/i20946a/Test_2.scala
@@ -0,0 +1,6 @@
+inline def macroWithAssertFailing[T](t: T): Unit = ${ macroWithAssertFailingImpl[T]('t) }
+
+@main
+def run =
+  macroWithAssertFailing[Int](123) // error
+

From facaa5662eb89f0ab6abeac84dbe8486efc7d232 Mon Sep 17 00:00:00 2001
From: Hamza Remmal <hamza@remmal.dev>
Date: Tue, 29 Oct 2024 15:05:13 +0100
Subject: [PATCH 088/306] Adapt the workflow to the transfer of the actions to
 the sdkman org

---
 .github/workflows/publish-sdkman.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/publish-sdkman.yml b/.github/workflows/publish-sdkman.yml
index 92123546dc4a..e47c95d01f19 100644
--- a/.github/workflows/publish-sdkman.yml
+++ b/.github/workflows/publish-sdkman.yml
@@ -46,7 +46,7 @@ jobs:
           - platform: WINDOWS_64
             archive : 'scala3-${{ inputs.version }}-x86_64-pc-win32.zip'
     steps:
-      - uses: hamzaremmal/sdkman-release-action@1f2d4209b4f5a38721d4ae20014ea8e1689d869e
+      - uses: sdkman/sdkman-release-action@1f2d4209b4f5a38721d4ae20014ea8e1689d869e
         with:
           CONSUMER-KEY   : ${{ secrets.CONSUMER-KEY }}
           CONSUMER-TOKEN : ${{ secrets.CONSUMER-TOKEN }}
@@ -59,7 +59,7 @@ jobs:
     runs-on: ubuntu-latest
     needs: publish
     steps:
-      - uses: hamzaremmal/sdkman-default-action@b3f991bd109e40155af1b13a4c6fc8e8ccada65e
+      - uses: sdkman/sdkman-default-action@b3f991bd109e40155af1b13a4c6fc8e8ccada65e
         with:
           CONSUMER-KEY   : ${{ secrets.CONSUMER-KEY }}
           CONSUMER-TOKEN : ${{ secrets.CONSUMER-TOKEN }}

From f16d5652e10dca2832c6a4c246910a7e733bded9 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Tue, 29 Oct 2024 17:35:53 +0100
Subject: [PATCH 089/306] Add note and a test to show the prefix rule for path
 subsuming

---
 .../src/dotty/tools/dotc/cc/CaptureRef.scala  |  6 +++
 .../captures/path-prefix.scala                | 44 +++++++++++++++++++
 2 files changed, 50 insertions(+)
 create mode 100644 tests/neg-custom-args/captures/path-prefix.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
index 61f18008cbad..8676390eda04 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
@@ -123,6 +123,12 @@ trait CaptureRef extends TypeProxy, ValueType:
                 this.subsumes(ypre)
                 || this.match
                     case x @ TermRef(xpre: CaptureRef, _) if x.symbol == y.symbol =>
+                      // To show `{x.f} <:< {y.f}`, it is important to prove `x` and `y`
+                      // are equvalent, which means `x =:= y` in terms for subtyping,
+                      // not just `{x} =:= {y}`.
+                      // It is posible to construct two singleton types `x` and `y`,
+                      // which subumse each other, but are not equal references.
+                      // See `tests/neg-custom-args/captures/path-prefix.scala` for example.
                       withMode(Mode.IgnoreCaptures) {TypeComparer.isSameRef(xpre, ypre)}
                     case _ =>
                       false
diff --git a/tests/neg-custom-args/captures/path-prefix.scala b/tests/neg-custom-args/captures/path-prefix.scala
new file mode 100644
index 000000000000..af5817636d0b
--- /dev/null
+++ b/tests/neg-custom-args/captures/path-prefix.scala
@@ -0,0 +1,44 @@
+import language.experimental.modularity
+import language.experimental.captureChecking
+import caps.Capability
+
+class F:
+  val f: AnyRef^ = ???
+
+case class B(tracked val a: A) extends F, Capability
+
+class A extends F, Capability:
+  val b: B { val a: A.this.type } = B(this)
+
+def test(a: A) =
+  val x: a.b.type = a.b
+  val y: x.a.type = x.a
+  // x and y are two distinct singleton types with following properties:
+  // x =:= a.b
+  // y =:= x.a =:= a.b.a =:= a
+
+  val cx: AnyRef^{x} = ???
+  val cy: AnyRef^{y} = ???
+  val caf: AnyRef^{a.f} = ???
+  val cabf: AnyRef^{a.b.f} = ???
+  val cxf: AnyRef^{x.f} = ???
+  val cyf: AnyRef^{y.f} = ???
+
+  // x and y subsume to each other:
+  // * {x} <:< {y}: the underlying singleton of y is x.a,
+  //   and the underlying singleton of x.a is a,
+  //   which is a prefix for the underlying type of x (a.b),
+  //   hence {x} <:< {y};
+  // * {y} <:< {x}: by underlying singleton of y is x.a, whose prefix is x.
+  // Hence, {x} =:= {y}.
+  val x2y: AnyRef^{y} = cx
+  val y2x: AnyRef^{x} = cy
+
+  val yf2af: AnyRef^{a.f} = cyf
+  val af2yf: AnyRef^{y.f} = caf
+  val xf2abf: AnyRef^{a.b.f} = cxf
+  val abf2xf: AnyRef^{x.f} = cabf
+
+  // Since `x !=:= y`, {x.f} !=:= {y.f}
+  val yf2xf: AnyRef^{x.f} = cyf // error
+  val xf2yf: AnyRef^{y.f} = cxf // error

From ad58323fb6e9a9c0bafa51db869168a084cee691 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Tue, 29 Oct 2024 17:40:05 +0100
Subject: [PATCH 090/306] Fix typo in the comment

---
 compiler/src/dotty/tools/dotc/cc/CaptureRef.scala | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
index 8676390eda04..590beda42903 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
@@ -124,10 +124,10 @@ trait CaptureRef extends TypeProxy, ValueType:
                 || this.match
                     case x @ TermRef(xpre: CaptureRef, _) if x.symbol == y.symbol =>
                       // To show `{x.f} <:< {y.f}`, it is important to prove `x` and `y`
-                      // are equvalent, which means `x =:= y` in terms for subtyping,
-                      // not just `{x} =:= {y}`.
-                      // It is posible to construct two singleton types `x` and `y`,
-                      // which subumse each other, but are not equal references.
+                      // are equvalent, which means `x =:= y` in terms of subtyping,
+                      // not just `{x} =:= {y}` in terms of subcapturing.
+                      // It is possible to construct two singleton types `x` and `y`,
+                      // which subsume each other, but are not equal references.
                       // See `tests/neg-custom-args/captures/path-prefix.scala` for example.
                       withMode(Mode.IgnoreCaptures) {TypeComparer.isSameRef(xpre, ypre)}
                     case _ =>

From 7d8f0d412844cd8468319ddbd542bb1452660f34 Mon Sep 17 00:00:00 2001
From: Natsu Kagami <nki@nkagami.me>
Date: Wed, 30 Oct 2024 11:17:33 +0100
Subject: [PATCH 091/306] Extract semanticDB for lifted definitions (#21856)

---
 .../dotc/semanticdb/ExtractSemanticDB.scala   | 14 ++++++
 .../dotty/tools/dotc/typer/EtaExpansion.scala | 13 ++----
 .../semanticdb/expect/Synthetic.expect.scala  |  9 ++++
 tests/semanticdb/expect/Synthetic.scala       |  9 ++++
 tests/semanticdb/metac.expect                 | 46 +++++++++++++++++--
 5 files changed, 76 insertions(+), 15 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala
index 8c1f22005af3..05dff8ffadbc 100644
--- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala
+++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala
@@ -286,6 +286,14 @@ object ExtractSemanticDB:
       || sym.owner == defn.OpsPackageClass
       || qualifier.exists(excludeQual)
 
+    /** This block is created by lifting i.e. EtaExpansion */
+    private def isProbablyLifted(block: Block)(using Context) =
+      def isSyntheticDef(t: Tree) =
+        t match
+          case t: (ValDef | DefDef) => t.symbol.isSyntheticWithIdent
+          case _ => false
+      block.stats.forall(isSyntheticDef)
+
     private def traverseAnnotsOfDefinition(sym: Symbol)(using Context): Unit =
       for annot <- sym.annotations do
         if annot.tree.span.exists
@@ -438,6 +446,12 @@ object ExtractSemanticDB:
               registerUseGuarded(None, sym, tree.span, tree.source)
             case _ => ()
 
+        // If tree is lifted, ignore Synthetic status on all the definitions and traverse all childrens
+        case tree: Block if isProbablyLifted(tree) =>
+          tree.stats.foreach:
+            case t: (ValDef | DefDef) if !excludeChildren(t.symbol) => traverseChildren(t)
+            case _ => ()
+          traverse(tree.expr)
 
         case _ =>
           traverseChildren(tree)
diff --git a/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala b/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
index b09580d51943..26d03db4b7dc 100644
--- a/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
+++ b/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
@@ -39,9 +39,6 @@ abstract class Lifter {
   /** 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 {
@@ -117,8 +114,7 @@ abstract class Lifter {
     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)
+      cpy.Apply(tree)(fn1, args1)
     case TypeApply(fn, targs) =>
       cpy.TypeApply(tree)(liftApp(defs, fn), targs)
     case Select(pre, name) if isPureRef(tree) =>
@@ -141,7 +137,7 @@ abstract class Lifter {
    *
    *  unless `pre` is idempotent.
    */
-  def liftNonIdempotentPrefix(defs: mutable.ListBuffer[Tree], tree: Tree)(using Context): Tree =
+  private def liftNonIdempotentPrefix(defs: mutable.ListBuffer[Tree], tree: Tree)(using Context): Tree =
     if (isIdempotentExpr(tree)) tree else lift(defs, tree)
 
   /** Lift prefix `pre` of an application `pre.f(...)` to
@@ -154,7 +150,7 @@ abstract class Lifter {
    *  Note that default arguments will refer to the prefix, we do not want
    *  to re-evaluate a complex expression each time we access a getter.
    */
-  def liftPrefix(defs: mutable.ListBuffer[Tree], tree: Tree)(using Context): Tree =
+  private def liftPrefix(defs: mutable.ListBuffer[Tree], tree: Tree)(using Context): Tree =
     tree match
       case tree: Literal => tree
       case tree: This => tree
@@ -218,9 +214,6 @@ object LiftCoverage extends LiftImpure {
   }
 }
 
-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
diff --git a/tests/semanticdb/expect/Synthetic.expect.scala b/tests/semanticdb/expect/Synthetic.expect.scala
index 4d797ce2b856..c8ccb2281cbb 100644
--- a/tests/semanticdb/expect/Synthetic.expect.scala
+++ b/tests/semanticdb/expect/Synthetic.expect.scala
@@ -58,4 +58,13 @@ class Synthetic/*<-example::Synthetic#*/ {
       given Int/*->scala::Int#*/ = 1
       foo/*->example::Synthetic#Contexts.foo().*/(0)
   }
+
+  // Argument lifting
+  val _ =
+    def f/*<-local14*/(s/*<-local12*/: String/*->scala::Predef.String#*/)(i/*<-local13*/: Int/*->scala::Int#*/ = s/*->local12*/.length/*->java::lang::String#length().*/()) = i/*->local13*/ +/*->scala::Int#`+`(+4).*/ 1
+    def g/*<-local18*/(s/*<-local16*/: String/*->scala::Predef.String#*/, t/*<-local17*/: String/*->scala::Predef.String#*/) = s/*->local16*/ +/*->java::lang::String#`+`().*/ t/*->local17*/
+
+    def impure/*<-local20*/(s/*<-local19*/: String/*->scala::Predef.String#*/) = { ???/*->scala::Predef.`???`().*/; s/*->local19*/ }
+    val _ = f/*->local14*/(impure/*->local20*/(""))()
+    val _ = g/*->local18*/(t/*->local17*/ = impure/*->local20*/(""), s/*->local16*/ = "a")
 }
diff --git a/tests/semanticdb/expect/Synthetic.scala b/tests/semanticdb/expect/Synthetic.scala
index 71fb5fdf70a3..0953d6cc4f98 100644
--- a/tests/semanticdb/expect/Synthetic.scala
+++ b/tests/semanticdb/expect/Synthetic.scala
@@ -58,4 +58,13 @@ class Synthetic {
       given Int = 1
       foo(0)
   }
+
+  // Argument lifting
+  val _ =
+    def f(s: String)(i: Int = s.length()) = i + 1
+    def g(s: String, t: String) = s + t
+
+    def impure(s: String) = { ???; s }
+    val _ = f(impure(""))()
+    val _ = g(t = impure(""), s = "a")
 }
diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect
index dffed5c0d477..26221899035b 100644
--- a/tests/semanticdb/metac.expect
+++ b/tests/semanticdb/metac.expect
@@ -2841,7 +2841,7 @@ Schema => SemanticDB v4
 Uri => NamedApplyBlock.scala
 Text => empty
 Language => Scala
-Symbols => 43 entries
+Symbols => 41 entries
 Occurrences => 41 entries
 
 Symbols:
@@ -2886,8 +2886,6 @@ example/NamedApplyBlockMethods.foo().(b) => param b: Int
 example/NamedApplyBlockMethods.foo().(c) => param c: Int
 example/NamedApplyBlockMethods.local. => val method local Int
 example/NamedApplyBlockMethods.recursive(). => method recursive => Int
-local0 => val local c$1: Int
-local1 => val local b$1: Int @uncheckedVariance
 
 Occurrences:
 [0:8..0:15): example <- example/
@@ -3533,8 +3531,8 @@ Schema => SemanticDB v4
 Uri => Synthetic.scala
 Text => empty
 Language => Scala
-Symbols => 52 entries
-Occurrences => 137 entries
+Symbols => 62 entries
+Occurrences => 165 entries
 Synthetics => 39 entries
 
 Symbols:
@@ -3590,6 +3588,16 @@ local8 => param a: Int
 local9 => param b: Int
 local10 => final implicit lazy val given local x: Int
 local11 => final implicit lazy val given local given_Int: Int
+local12 => param s: String
+local13 => param i: Int
+local14 => local f: (param s: String)(param i: Int): Int
+local15 => local f$default$2: (param s: String): Int @uncheckedVariance
+local15(s) => param s: String
+local16 => param s: String
+local17 => param t: String
+local18 => local g: (param s: String, param t: String): String
+local19 => param s: String
+local20 => local impure: (param s: String): String
 
 Occurrences:
 [0:8..0:15): example <- example/
@@ -3729,6 +3737,34 @@ Occurrences:
 [56:8..56:10): m4 <- example/Synthetic#Contexts.m4().
 [57:12..57:15): Int -> scala/Int#
 [58:6..58:9): foo -> example/Synthetic#Contexts.foo().
+[63:8..63:9): f <- local14
+[63:10..63:11): s <- local12
+[63:13..63:19): String -> scala/Predef.String#
+[63:21..63:22): i <- local13
+[63:24..63:27): Int -> scala/Int#
+[63:30..63:31): s -> local12
+[63:32..63:38): length -> java/lang/String#length().
+[63:44..63:45): i -> local13
+[63:46..63:47): + -> scala/Int#`+`(+4).
+[64:8..64:9): g <- local18
+[64:10..64:11): s <- local16
+[64:13..64:19): String -> scala/Predef.String#
+[64:21..64:22): t <- local17
+[64:24..64:30): String -> scala/Predef.String#
+[64:34..64:35): s -> local16
+[64:36..64:37): + -> java/lang/String#`+`().
+[64:38..64:39): t -> local17
+[66:8..66:14): impure <- local20
+[66:15..66:16): s <- local19
+[66:18..66:24): String -> scala/Predef.String#
+[66:30..66:33): ??? -> scala/Predef.`???`().
+[66:35..66:36): s -> local19
+[67:12..67:13): f -> local14
+[67:14..67:20): impure -> local20
+[68:12..68:13): g -> local18
+[68:14..68:15): t -> local17
+[68:18..68:24): impure -> local20
+[68:30..68:31): s -> local16
 
 Synthetics:
 [5:2..5:13):List(1).map => *[Int]

From 7b721f0fdc032e871737d11ed1841c9fdc4ef98d Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 30 Oct 2024 14:04:44 +0000
Subject: [PATCH 092/306] Simplify transformIsInstanceOf check

---
 .../src/dotty/tools/dotc/transform/TypeTestsCasts.scala  | 9 +++------
 tests/pos/i21544.scala                                   | 2 ++
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
index 45596e1d47f6..c1dd6bc6509e 100644
--- a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
@@ -256,7 +256,8 @@ object TypeTestsCasts {
             else foundClasses.exists(check)
           end checkSensical
 
-          if (expr.tpe <:< testType) && inMatch then
+          val tp = if expr.tpe.isPrimitiveValueType then defn.boxedType(expr.tpe) else expr.tpe
+          if tp <:< testType && inMatch then
             if expr.tpe.isNotNull then constant(expr, Literal(Constant(true)))
             else expr.testNotNull
           else {
@@ -358,11 +359,7 @@ object TypeTestsCasts {
                 report.error(em"$untestable cannot be used in runtime type tests", tree.srcPos)
                 constant(expr, Literal(Constant(false)))
               case _ =>
-                val erasedTestType =
-                  if testType.isAny && expr.tpe.isPrimitiveValueType then
-                    defn.AnyValType
-                  else
-                    erasure(testType)
+                val erasedTestType = erasure(testType)
                 transformIsInstanceOf(expr, erasedTestType, erasedTestType, flagUnrelated)
         }
 
diff --git a/tests/pos/i21544.scala b/tests/pos/i21544.scala
index 45da101e7490..08a3911e4412 100644
--- a/tests/pos/i21544.scala
+++ b/tests/pos/i21544.scala
@@ -1,2 +1,4 @@
 class Test():
   def m1(xs: List[Boolean]) = for (x: Any) <- xs yield x
+  def m2(xs: List[Boolean]) = for (x: AnyVal) <- xs yield x
+  def m3(xs: List[Boolean]) = for (x: Matchable) <- xs yield x

From ae9cffa3a3c736103ca3bec2742b7fd7c2b930ac Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Wed, 30 Oct 2024 15:58:33 +0100
Subject: [PATCH 093/306] Change inContextBound to a Boolean flag

---
 .../src/dotty/tools/dotc/parsing/Parsers.scala    | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 1a5b270f2a48..01cbbe34b3b4 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -80,9 +80,6 @@ object Parsers {
   enum IntoOK:
     case Yes, No, Nested
 
-  enum InContextBound:
-    case Yes, No
-
   type StageKind = Int
   object StageKind {
     val None = 0
@@ -1553,7 +1550,7 @@ object Parsers {
     /** 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(intoOK: IntoOK = IntoOK.No, inContextBound: InContextBound = InContextBound.No): Tree =
+    def toplevelTyp(intoOK: IntoOK = IntoOK.No, inContextBound: Boolean = false): Tree =
       rejectWildcardType(typ(intoOK, inContextBound))
 
     private def getFunction(tree: Tree): Option[Function] = tree match {
@@ -1609,7 +1606,7 @@ object Parsers {
      *  IntoTargetType ::=  Type
      *                   |  FunTypeArgs (‘=>’ | ‘?=>’) IntoType
      */
-    def typ(intoOK: IntoOK = IntoOK.No, inContextBound: InContextBound = InContextBound.No): Tree =
+    def typ(intoOK: IntoOK = IntoOK.No, inContextBound: Boolean = false): Tree =
       val start = in.offset
       var imods = Modifiers()
       val erasedArgs: ListBuffer[Boolean] = ListBuffer()
@@ -1836,13 +1833,13 @@ object Parsers {
     /** InfixType ::= RefinedType {id [nl] RefinedType}
      *             |  RefinedType `^`   // under capture checking
      */
-    def infixType(inContextBound: InContextBound = InContextBound.No): Tree = infixTypeRest(inContextBound)(refinedType())
+    def infixType(inContextBound: Boolean = false): Tree = infixTypeRest(inContextBound)(refinedType())
 
-    def infixTypeRest(inContextBound: InContextBound = InContextBound.No)(t: Tree, operand: Location => Tree = refinedTypeFn): Tree =
+    def infixTypeRest(inContextBound: Boolean = false)(t: Tree, operand: Location => Tree = refinedTypeFn): Tree =
       infixOps(t, canStartInfixTypeTokens, operand, Location.ElseWhere, ParseKind.Type,
         isOperator = !followingIsVararg()
                      && !isPureArrow
-                     && !(isIdent(nme.as) && sourceVersion.isAtLeast(`3.6`) && inContextBound == InContextBound.Yes)
+                     && !(isIdent(nme.as) && sourceVersion.isAtLeast(`3.6`) && inContextBound)
                      && nextCanFollowOperator(canStartInfixTypeTokens))
 
     /** RefinedType   ::=  WithType {[nl] Refinement} [`^` CaptureSet]
@@ -2233,7 +2230,7 @@ object Parsers {
 
     /** ContextBound      ::=  Type [`as` id] */
     def contextBound(pname: TypeName): Tree =
-      val t = toplevelTyp(inContextBound = InContextBound.Yes)
+      val t = toplevelTyp(inContextBound = true)
       val ownName =
         if isIdent(nme.as) && sourceVersion.isAtLeast(`3.6`) then
           in.nextToken()

From 17dadf791a5b42eb406227901b1c16940e1537cb Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 29 Oct 2024 17:52:13 +0000
Subject: [PATCH 094/306] Fix extending protected nested java classes

PR 21362 added an accessibility fix to Erasure, but that revealed a
mistake in determining the accessibility of inner java classes, which
I'm now fixing.
---
 .../dotty/tools/dotc/core/classfile/ClassfileParser.scala  | 3 ++-
 compiler/src/dotty/tools/dotc/printing/Formatting.scala    | 7 +++++++
 tests/pos/i21631_joint/AbstractChannel.java                | 7 +++++++
 tests/pos/i21631_joint/i21631.scala                        | 5 +++++
 tests/pos/i21631_separ/AbstractChannel_1.java              | 7 +++++++
 tests/pos/i21631_separ/i21631_2.scala                      | 5 +++++
 6 files changed, 33 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i21631_joint/AbstractChannel.java
 create mode 100644 tests/pos/i21631_joint/i21631.scala
 create mode 100644 tests/pos/i21631_separ/AbstractChannel_1.java
 create mode 100644 tests/pos/i21631_separ/i21631_2.scala

diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
index 9e7b59a0cfac..f6ad61148208 100644
--- a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
+++ b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
@@ -401,7 +401,8 @@ class ClassfileParser(
       classRoot.setFlag(sflags)
       moduleRoot.setFlag(Flags.JavaDefined | Flags.ModuleClassCreationFlags)
 
-      val privateWithin = getPrivateWithin(jflags)
+      val jflags1 = innerClasses.get(currentClassName.toString).fold(jflags: Int)(_.jflags)
+      val privateWithin = getPrivateWithin(jflags1)
 
       classRoot.setPrivateWithin(privateWithin)
       moduleRoot.setPrivateWithin(privateWithin)
diff --git a/compiler/src/dotty/tools/dotc/printing/Formatting.scala b/compiler/src/dotty/tools/dotc/printing/Formatting.scala
index a36e6f48533a..14b822b11333 100644
--- a/compiler/src/dotty/tools/dotc/printing/Formatting.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Formatting.scala
@@ -109,6 +109,13 @@ object Formatting {
           case Atoms.Range(lo, hi) => CtxShow(s"Range(${toStr(lo.toList)}, ${toStr(hi.toList)})")
       end given
 
+      given Show[ast.untpd.Modifiers] with
+        def show(x: ast.untpd.Modifiers) =
+          CtxShow(s"Modifiers(${toStr(x.flags)}, ${toStr(x.privateWithin)}, ${toStr(x.annotations)}, ${toStr(x.mods)})")
+
+      given Show[ast.untpd.Mod] with
+        def show(x: ast.untpd.Mod) = CtxShow(s"Mod(${toStr(x.flags)})")
+
       given Show[Showable]                            = ShowAny
       given Show[Shown]                               = ShowAny
       given Show[Int]                                 = ShowAny
diff --git a/tests/pos/i21631_joint/AbstractChannel.java b/tests/pos/i21631_joint/AbstractChannel.java
new file mode 100644
index 000000000000..fbcd04549def
--- /dev/null
+++ b/tests/pos/i21631_joint/AbstractChannel.java
@@ -0,0 +1,7 @@
+public abstract class AbstractChannel {
+    protected AbstractChannel() {}
+    protected abstract AbstractUnsafe newUnsafe();
+    protected abstract class AbstractUnsafe {
+        public abstract void connect();
+    }
+}
diff --git a/tests/pos/i21631_joint/i21631.scala b/tests/pos/i21631_joint/i21631.scala
new file mode 100644
index 000000000000..c567d75b1375
--- /dev/null
+++ b/tests/pos/i21631_joint/i21631.scala
@@ -0,0 +1,5 @@
+class Channel extends AbstractChannel() {
+  override def newUnsafe(): AbstractChannel#AbstractUnsafe = new AbstractUnsafe {
+    override def connect(): Unit = ???
+  }
+}
diff --git a/tests/pos/i21631_separ/AbstractChannel_1.java b/tests/pos/i21631_separ/AbstractChannel_1.java
new file mode 100644
index 000000000000..e89767d6d73e
--- /dev/null
+++ b/tests/pos/i21631_separ/AbstractChannel_1.java
@@ -0,0 +1,7 @@
+public abstract class AbstractChannel_1 {
+    protected AbstractChannel_1() {}
+    protected abstract AbstractUnsafe newUnsafe();
+    protected abstract class AbstractUnsafe {
+        public abstract void connect();
+    }
+}
diff --git a/tests/pos/i21631_separ/i21631_2.scala b/tests/pos/i21631_separ/i21631_2.scala
new file mode 100644
index 000000000000..89524e333920
--- /dev/null
+++ b/tests/pos/i21631_separ/i21631_2.scala
@@ -0,0 +1,5 @@
+class Channel extends AbstractChannel_1() {
+  override def newUnsafe(): AbstractChannel_1#AbstractUnsafe = new AbstractUnsafe {
+    override def connect(): Unit = ???
+  }
+}

From 7aebb9dab2e557aff2b3276ecd6ad5e31bf357e3 Mon Sep 17 00:00:00 2001
From: Tomasz Godzik <tgodzik@virtuslab.com>
Date: Thu, 31 Oct 2024 13:11:38 +0100
Subject: [PATCH 095/306] improvement: Disable projects not compiling with
 Bloop

---
 docs/_docs/contributing/setting-up-your-ide.md |  6 +++---
 project/Build.scala                            | 12 +++++++++++-
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/docs/_docs/contributing/setting-up-your-ide.md b/docs/_docs/contributing/setting-up-your-ide.md
index a15bf651ef74..3779ce1c3403 100644
--- a/docs/_docs/contributing/setting-up-your-ide.md
+++ b/docs/_docs/contributing/setting-up-your-ide.md
@@ -31,15 +31,15 @@ Normally this is fine, but if you're working on certain modules like `scaladoc`
 you'll actually want these modules exported. In order to achieve this you'll
 want to make sure you do two things:
 
-1. You'll want to find and change the following under
+1. You'll want to find and change the following above
    `commonBootstrappedSettings` which is found in the
    [`Build.scala`](https://github.com/scala/scala3/blob/main/project/Build.scala)
    file.
 
 ```diff
 
--    bspEnabled := false,
-+    bspEnabled := true,
+-    val enableBspAllProjects = false,
++    val enableBspAllProjects = true,
 ```
 
 2. Run `sbt publishLocal` to get the needed presentation compiler jars.
diff --git a/project/Build.scala b/project/Build.scala
index 6ec933a599b3..d955f7067626 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -468,10 +468,20 @@ object Build {
     ) ++ extMap
   }
 
+  /* This projects are irrelevant from IDE point of view and do not compile with Bloop*/
+  val fullyDisabledProjects = Set(
+    "scala2-library-cc",
+    "scala2-library-bootstrapped",
+    "scala2-library-cc-tasty",
+    "scala2-library-tasty"
+  )
+
+  val enableBspAllProjects = false
+
   // Settings used when compiling dotty with a non-bootstrapped dotty
   lazy val commonBootstrappedSettings = commonDottySettings ++ Seq(
     // To enable support of scaladoc and language-server projects you need to change this to true
-    bspEnabled := false,
+    bspEnabled := { if(fullyDisabledProjects(name.value)) false else enableBspAllProjects },
     (Compile / unmanagedSourceDirectories) += baseDirectory.value / "src-bootstrapped",
 
     version := dottyVersion,

From 09e96e2f08bbfa743fb3184be6ff82421bd62303 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Thu, 31 Oct 2024 12:43:30 +0000
Subject: [PATCH 096/306] Fix Java parsing of annotations on qualified types

According to [#1][#1] this is valid syntax:

    java.lang.@NonNull String

  [#1]: https://checkerframework.org/jsr308/specification/java-annotation-design.html#qualified-type-syntax
---
 .../dotty/tools/dotc/parsing/JavaParsers.scala  |  1 +
 tests/pos/i21319/Foo.java                       |  8 ++++++++
 tests/pos/i21319/Test.scala                     |  3 +++
 tests/pos/i21319/Valid.java                     | 17 +++++++++++++++++
 4 files changed, 29 insertions(+)
 create mode 100644 tests/pos/i21319/Foo.java
 create mode 100644 tests/pos/i21319/Test.scala
 create mode 100644 tests/pos/i21319/Valid.java

diff --git a/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala b/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
index 8a9eca2c1e67..fe797c66d104 100644
--- a/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
@@ -298,6 +298,7 @@ object JavaParsers {
           }
           while (in.token == DOT) {
             in.nextToken()
+            annotations()
             t = typeArgs(atSpan(t.span.start, in.offset)(typeSelect(t, ident())))
           }
           convertToTypeId(t)
diff --git a/tests/pos/i21319/Foo.java b/tests/pos/i21319/Foo.java
new file mode 100644
index 000000000000..1240d014b7e7
--- /dev/null
+++ b/tests/pos/i21319/Foo.java
@@ -0,0 +1,8 @@
+package app;
+
+import java.util.Optional;
+import lib.*;
+
+public class Foo {
+  private java.util.@lib.Valid Optional<String> userId;
+}
diff --git a/tests/pos/i21319/Test.scala b/tests/pos/i21319/Test.scala
new file mode 100644
index 000000000000..a85c8f461aab
--- /dev/null
+++ b/tests/pos/i21319/Test.scala
@@ -0,0 +1,3 @@
+package app
+
+class Test
diff --git a/tests/pos/i21319/Valid.java b/tests/pos/i21319/Valid.java
new file mode 100644
index 000000000000..17e0e1173726
--- /dev/null
+++ b/tests/pos/i21319/Valid.java
@@ -0,0 +1,17 @@
+package lib;
+
+import static java.lang.annotation.ElementType.CONSTRUCTOR;
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.PARAMETER;
+import static java.lang.annotation.ElementType.TYPE_USE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+@Target({ METHOD, FIELD, CONSTRUCTOR, PARAMETER, TYPE_USE })
+@Retention(RUNTIME)
+@Documented
+public @interface Valid {}

From c450073b308364217a203cf8bd2c7c09212da475 Mon Sep 17 00:00:00 2001
From: Tomasz Godzik <tgodzik@users.noreply.github.com>
Date: Thu, 31 Oct 2024 15:26:51 +0100
Subject: [PATCH 097/306] Fix typo
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Sébastien Doeraene <sjrdoeraene@gmail.com>
---
 project/Build.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project/Build.scala b/project/Build.scala
index d955f7067626..5b357dab6ef6 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -468,7 +468,7 @@ object Build {
     ) ++ extMap
   }
 
-  /* This projects are irrelevant from IDE point of view and do not compile with Bloop*/
+  /* These projects are irrelevant from IDE point of view and do not compile with Bloop*/
   val fullyDisabledProjects = Set(
     "scala2-library-cc",
     "scala2-library-bootstrapped",

From 350215dcaad554accccef37502033439a6d09caf Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Thu, 31 Oct 2024 18:44:04 +0000
Subject: [PATCH 098/306] Set privateWithin when creating java inner classes

---
 .../dotty/tools/dotc/core/SymbolLoaders.scala |  3 ++-
 .../dotc/core/classfile/ClassfileParser.scala | 19 ++++++++++++-------
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala b/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
index 5690720a1b3f..585db8488a78 100644
--- a/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
@@ -103,13 +103,14 @@ object SymbolLoaders {
    */
   def enterClassAndModule(
       owner: Symbol, name: PreName, completer: SymbolLoader,
-      flags: FlagSet = EmptyFlags, scope: Scope = EmptyScope)(using Context): Unit = {
+      flags: FlagSet = EmptyFlags, scope: Scope = EmptyScope)(using Context): (Symbol, Symbol) = {
     val clazz = enterClass(owner, name, completer, flags, scope)
     val module = enterModule(
       owner, name, completer,
       modFlags = flags.toTermFlags & RetainedModuleValFlags,
       clsFlags = flags.toTypeFlags & RetainedModuleClassFlags,
       scope = scope)
+    (clazz, module)
   }
 
   /** Enter all toplevel classes and objects in file `src` into package `owner`, provided
diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
index f6ad61148208..4b0dec2c88b7 100644
--- a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
+++ b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
@@ -401,12 +401,12 @@ class ClassfileParser(
       classRoot.setFlag(sflags)
       moduleRoot.setFlag(Flags.JavaDefined | Flags.ModuleClassCreationFlags)
 
-      val jflags1 = innerClasses.get(currentClassName.toString).fold(jflags: Int)(_.jflags)
-      val privateWithin = getPrivateWithin(jflags1)
+      val privateWithin = getPrivateWithin(jflags)
 
-      classRoot.setPrivateWithin(privateWithin)
-      moduleRoot.setPrivateWithin(privateWithin)
-      moduleRoot.sourceModule.setPrivateWithin(privateWithin)
+      if privateWithin.exists then
+        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)
@@ -1059,13 +1059,18 @@ class ClassfileParser(
    */
   private def enterOwnInnerClasses()(using Context, DataReader): Unit = {
     def enterClassAndModule(entry: InnerClassEntry, file: AbstractFile, jflags: Int) =
-      SymbolLoaders.enterClassAndModule(
+      val (cls, mod) = SymbolLoaders.enterClassAndModule(
           getOwner(jflags),
-          entry.originalName,
+        entry.originalName,
           new ClassfileLoader(file),
           classTranslation.flags(jflags),
           getScope(jflags))
 
+      val privateWithin = getPrivateWithin(jflags)
+      cls.setPrivateWithin(privateWithin)
+      mod.setPrivateWithin(privateWithin)
+      mod.sourceModule.setPrivateWithin(privateWithin)
+
     for entry <- innerClasses.valuesIterator do
       // create a new class member for immediate inner classes
       if entry.outer.name == currentClassName then

From 014d0dbb4df6ee6b93aad7692a35996c962cded6 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Fri, 1 Nov 2024 10:28:32 +0100
Subject: [PATCH 099/306] Change tests for i20946 to only check the assert
 message in code

---
 .../scala/quoted/runtime/impl/QuotesImpl.scala |  6 +++---
 tests/neg/i20946.check                         | 18 ------------------
 tests/neg/i20946/Macro_1.scala                 |  8 ++++++--
 tests/neg/i20946/Test_2.scala                  |  1 -
 tests/neg/i20946a.check                        | 18 ------------------
 tests/neg/i20946a/Macro_1.scala                |  8 ++++++--
 tests/neg/i20946a/Test_2.scala                 |  1 -
 7 files changed, 15 insertions(+), 45 deletions(-)
 delete mode 100644 tests/neg/i20946.check
 delete mode 100644 tests/neg/i20946a.check

diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index abda4aa191a9..ef2eacf42225 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -301,7 +301,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     object DefDef extends DefDefModule:
       def apply(symbol: Symbol, rhsFn: List[List[Tree]] => Option[Term]): DefDef =
-        xCheckMacroAssert(symbol.isTerm, s"expected a term symbol but received $symbol")
+        xCheckMacroAssert(symbol.isTerm, s"expected a term symbol, but received $symbol")
         xCheckMacroAssert(symbol.flags.is(Flags.Method), "expected a symbol with `Method` flag set")
         withDefaultPos(tpd.DefDef(symbol.asTerm, prefss =>
           xCheckedMacroOwners(xCheckMacroValidExpr(rhsFn(prefss)), symbol).getOrElse(tpd.EmptyTree)
@@ -472,7 +472,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def term(tp: TermRef): Ref =
         withDefaultPos(tpd.ref(tp).asInstanceOf[tpd.RefTree])
       def apply(sym: Symbol): Ref =
-        assert(sym.isTerm, s"expected a term symbol but received $sym")
+        assert(sym.isTerm, s"expected a term symbol, but received $sym")
         val refTree = tpd.ref(sym) match
           case t @ tpd.This(ident) => // not a RefTree, so we need to work around this - issue #19732
             // ident in `This` can be a TypeIdent of sym, so we manually prepare the ref here,
@@ -1128,7 +1128,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def of[T <: AnyKind](using tp: scala.quoted.Type[T]): TypeTree =
         tp.asInstanceOf[TypeImpl].typeTree
       def ref(sym: Symbol): TypeTree =
-        assert(sym.isType, "Expected a type symbol, but got " + sym)
+        assert(sym.isType, s"Expected a type symbol, but got $sym")
         tpd.ref(sym)
     end TypeTree
 
diff --git a/tests/neg/i20946.check b/tests/neg/i20946.check
deleted file mode 100644
index acce8bf4852d..000000000000
--- a/tests/neg/i20946.check
+++ /dev/null
@@ -1,18 +0,0 @@
-
--- Error: tests/neg/i20946/Test_2.scala:5:29 ---------------------------------------------------------------------------
-5 |  macroWithAssertFailing[Int](123) // error
-  |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |  Exception occurred while executing macro expansion.
-  |  java.lang.AssertionError: assertion failed: expected a term symbol but received class Int
-  |  	at scala.runtime.Scala3RunTime$.assertFailed(Scala3RunTime.scala:8)
-  |  	at scala.quoted.runtime.impl.QuotesImpl$reflect$Ref$.apply(QuotesImpl.scala:475)
-  |  	at scala.quoted.runtime.impl.QuotesImpl$reflect$Ref$.apply(QuotesImpl.scala:474)
-  |  	at Macro_1$package$.macroWithAssertFailingImpl(Macro_1.scala:6)
-  |
-  |---------------------------------------------------------------------------------------------------------------------
-  |Inline stack trace
-  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  |This location contains code that was inlined from Test_2.scala:1
-1 |inline def macroWithAssertFailing[T](t: T): Unit = ${ macroWithAssertFailingImpl[T]('t) }
-  |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   ---------------------------------------------------------------------------------------------------------------------
diff --git a/tests/neg/i20946/Macro_1.scala b/tests/neg/i20946/Macro_1.scala
index 0f2bb8416a0c..f598f5d278ce 100644
--- a/tests/neg/i20946/Macro_1.scala
+++ b/tests/neg/i20946/Macro_1.scala
@@ -3,8 +3,12 @@ import scala.quoted.*
 def macroWithAssertFailingImpl[T: Type](t: Expr[T])(using Quotes): Expr[Unit] = {
   import quotes.reflect.*
 
-  Ref(TypeRepr.of[T].typeSymbol)
+  try
+    Ref(TypeRepr.of[T].typeSymbol)
+  catch
+    case ex: Throwable =>
+      if ex.getMessage().contains("expected a term symbol, but received ") then
+        throw ex
 
   '{()}
 }
-
diff --git a/tests/neg/i20946/Test_2.scala b/tests/neg/i20946/Test_2.scala
index 79a02ff1a5db..80ae0a95fa4b 100644
--- a/tests/neg/i20946/Test_2.scala
+++ b/tests/neg/i20946/Test_2.scala
@@ -3,4 +3,3 @@ inline def macroWithAssertFailing[T](t: T): Unit = ${ macroWithAssertFailingImpl
 @main
 def run =
   macroWithAssertFailing[Int](123) // error
-
diff --git a/tests/neg/i20946a.check b/tests/neg/i20946a.check
deleted file mode 100644
index f279a60a4798..000000000000
--- a/tests/neg/i20946a.check
+++ /dev/null
@@ -1,18 +0,0 @@
-
--- Error: tests/neg/i20946a/Test_2.scala:5:29 --------------------------------------------------------------------------
-5 |  macroWithAssertFailing[Int](123) // error
-  |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |  Exception occurred while executing macro expansion.
-  |  java.lang.AssertionError: assertion failed: Expected a type symbol, but got val <none>
-  |  	at scala.runtime.Scala3RunTime$.assertFailed(Scala3RunTime.scala:8)
-  |  	at scala.quoted.runtime.impl.QuotesImpl$reflect$TypeIdent$.apply(QuotesImpl.scala:1165)
-  |  	at scala.quoted.runtime.impl.QuotesImpl$reflect$TypeIdent$.apply(QuotesImpl.scala:1164)
-  |  	at Macro_1$package$.macroWithAssertFailingImpl(Macro_1.scala:6)
-  |
-  |---------------------------------------------------------------------------------------------------------------------
-  |Inline stack trace
-  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  |This location contains code that was inlined from Test_2.scala:1
-1 |inline def macroWithAssertFailing[T](t: T): Unit = ${ macroWithAssertFailingImpl[T]('t) }
-  |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   ---------------------------------------------------------------------------------------------------------------------
diff --git a/tests/neg/i20946a/Macro_1.scala b/tests/neg/i20946a/Macro_1.scala
index c0e9e6eec116..b3603fe91b10 100644
--- a/tests/neg/i20946a/Macro_1.scala
+++ b/tests/neg/i20946a/Macro_1.scala
@@ -3,8 +3,12 @@ import scala.quoted.*
 def macroWithAssertFailingImpl[T: Type](t: Expr[T])(using Quotes): Expr[Unit] = {
   import quotes.reflect.*
 
-  TypeIdent(t.asTerm.symbol)
+  try
+    TypeIdent(t.asTerm.symbol)
+  catch
+    case ex: Throwable =>
+      if ex.getMessage().contains("Expected a type symbol, but got ") then
+        throw ex
 
   '{()}
 }
-
diff --git a/tests/neg/i20946a/Test_2.scala b/tests/neg/i20946a/Test_2.scala
index 79a02ff1a5db..80ae0a95fa4b 100644
--- a/tests/neg/i20946a/Test_2.scala
+++ b/tests/neg/i20946a/Test_2.scala
@@ -3,4 +3,3 @@ inline def macroWithAssertFailing[T](t: T): Unit = ${ macroWithAssertFailingImpl
 @main
 def run =
   macroWithAssertFailing[Int](123) // error
-

From 2f61ee2648fa35ed66d6a1f03b449032ea9ee316 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Fri, 1 Nov 2024 01:43:21 +0100
Subject: [PATCH 100/306] Ensure to escape characters before constructing JSON
 profile trace

---
 .../dotc/profile/JsonNameTransformer.scala    |  47 +++++++
 .../dotty/tools/dotc/profile/Profiler.scala   |  15 +-
 compiler/test/dotty/tools/DottyTest.scala     |   2 +-
 .../dotc/profile/TraceNameManglingTest.scala  | 133 ++++++++++++++++++
 4 files changed, 191 insertions(+), 6 deletions(-)
 create mode 100644 compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala
 create mode 100644 compiler/test/dotty/tools/dotc/profile/TraceNameManglingTest.scala

diff --git a/compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala b/compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala
new file mode 100644
index 000000000000..a1bb5f9552c5
--- /dev/null
+++ b/compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala
@@ -0,0 +1,47 @@
+package dotty.tools.dotc.profile
+
+import scala.annotation.internal.sharable
+
+// Based on NameTransformer but dedicated for JSON encoding rules
+object JsonNameTransformer {
+  private val nops = 128
+  private val ncodes = 26 * 26
+
+  @sharable private val op2code = new Array[String](nops)
+  private def enterOp(op: Char, code: String) = op2code(op.toInt) = code
+
+  enterOp('\"', "\\\"")
+  enterOp('\\', "\\\\")
+  // enterOp('/', "\\/") // optional, no need for escaping outside of html context
+  enterOp('\b', "\\b")
+  enterOp('\f', "\\f")
+  enterOp('\n', "\\n")
+  enterOp('\r', "\\r")
+  enterOp('\t', "\\t")
+
+  def encode(name: String): String = {
+    var buf: StringBuilder = null.asInstanceOf
+    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.subSequence(0, i))
+        }
+        buf.append(op2code(c.toInt))
+      } else if (c <= 0x1F || c > 0x7F) {
+        if (buf eq null) {
+          buf = new StringBuilder()
+          buf.append(name.subSequence(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 buf.toString
+  }
+}
\ No newline at end of file
diff --git a/compiler/src/dotty/tools/dotc/profile/Profiler.scala b/compiler/src/dotty/tools/dotc/profile/Profiler.scala
index 69a806215ddd..ab3e73468385 100644
--- a/compiler/src/dotty/tools/dotc/profile/Profiler.scala
+++ b/compiler/src/dotty/tools/dotc/profile/Profiler.scala
@@ -273,7 +273,7 @@ private [profile] class RealProfiler(reporter : ProfileReporter)(using Context)
   override def beforePhase(phase: Phase): (TracedEventId, ProfileSnap) = {
     assert(mainThread eq Thread.currentThread())
     traceThreadSnapshotCounters()
-    val eventId = traceDurationStart(Category.Phase, phase.phaseName)
+    val eventId = traceDurationStart(Category.Phase, escapeSpecialChars(phase.phaseName))
     if (ctx.settings.YprofileRunGcBetweenPhases.value.contains(phase.toString))
       doGC()
     if (ctx.settings.YprofileExternalTool.value.contains(phase.toString)) {
@@ -287,7 +287,7 @@ private [profile] class RealProfiler(reporter : ProfileReporter)(using Context)
     assert(mainThread eq Thread.currentThread())
     if chromeTrace != null then
       traceThreadSnapshotCounters()
-      traceDurationStart(Category.File, unit.source.name)
+      traceDurationStart(Category.File, escapeSpecialChars(unit.source.name))
     else TracedEventId.Empty
   }
 
@@ -325,7 +325,7 @@ private [profile] class RealProfiler(reporter : ProfileReporter)(using Context)
     then EmptyCompletionEvent
     else
       val completionName = this.completionName(root, associatedFile)
-      val event = TracedEventId(associatedFile.name)
+      val event = TracedEventId(escapeSpecialChars(associatedFile.name))
       chromeTrace.traceDurationEventStart(Category.Completion.name, "↯", colour = "thread_state_sleeping")
       chromeTrace.traceDurationEventStart(Category.File.name, event)
       chromeTrace.traceDurationEventStart(Category.Completion.name, completionName)
@@ -350,8 +350,13 @@ private [profile] class RealProfiler(reporter : ProfileReporter)(using Context)
     if chromeTrace != null then
       chromeTrace.traceDurationEventEnd(category.name, event, colour)
 
-  private def symbolName(sym: Symbol): String = s"${sym.showKind} ${sym.showName}"
-  private def completionName(root: Symbol, associatedFile: AbstractFile): String =
+  private inline def escapeSpecialChars(value: String): String =
+    JsonNameTransformer.encode(value)
+
+  private def symbolName(sym: Symbol): String = escapeSpecialChars:
+    s"${sym.showKind} ${sym.showName}"
+
+  private def completionName(root: Symbol, associatedFile: AbstractFile): String = escapeSpecialChars:
     def isTopLevel = root.owner != NoSymbol && root.owner.is(Flags.Package)
     if root.is(Flags.Package) || isTopLevel
     then root.javaBinaryName
diff --git a/compiler/test/dotty/tools/DottyTest.scala b/compiler/test/dotty/tools/DottyTest.scala
index 2b94801b67d7..76d2fdcb6d26 100644
--- a/compiler/test/dotty/tools/DottyTest.scala
+++ b/compiler/test/dotty/tools/DottyTest.scala
@@ -46,7 +46,7 @@ trait DottyTest extends ContextEscapeDetection {
 
   protected def defaultCompiler: Compiler = new Compiler()
 
-  private def compilerWithChecker(phase: String)(assertion: (tpd.Tree, Context) => Unit) = new Compiler {
+  protected def compilerWithChecker(phase: String)(assertion: (tpd.Tree, Context) => Unit) = new Compiler {
 
     private val baseCompiler = defaultCompiler
 
diff --git a/compiler/test/dotty/tools/dotc/profile/TraceNameManglingTest.scala b/compiler/test/dotty/tools/dotc/profile/TraceNameManglingTest.scala
new file mode 100644
index 000000000000..977b67740f88
--- /dev/null
+++ b/compiler/test/dotty/tools/dotc/profile/TraceNameManglingTest.scala
@@ -0,0 +1,133 @@
+package dotty.tools.dotc.profile
+
+import org.junit.Assert.*
+import org.junit.*
+
+import scala.annotation.tailrec
+import dotty.tools.DottyTest
+import dotty.tools.dotc.util.SourceFile
+import dotty.tools.dotc.core.Contexts.FreshContext
+import java.nio.file.Files
+import java.util.Locale
+
+class TraceNameManglingTest extends DottyTest {
+
+  override protected def initializeCtx(fc: FreshContext): Unit = {
+    super.initializeCtx(fc)
+    val tmpDir = Files.createTempDirectory("trace_name_mangling_test").nn
+    fc.setSetting(fc.settings.YprofileEnabled, true)
+    fc.setSetting(
+      fc.settings.YprofileTrace,
+      tmpDir.resolve("trace.json").nn.toAbsolutePath().toString()
+    )
+    fc.setSetting(
+      fc.settings.YprofileDestination,
+      tmpDir.resolve("profiler.out").nn.toAbsolutePath().toString()
+    )
+  }
+
+  @Test def escapeBackslashes(): Unit = {
+    val isWindows = sys.props("os.name").toLowerCase(Locale.ROOT) == "windows"
+    val filename = if isWindows then "/.scala" else "\\.scala"
+    checkTraceEvents(
+      """
+      |class /\ :
+      |  var /\ = ???
+      |object /\{
+      |  def /\ = ???
+      |}""".stripMargin,
+      filename = filename
+    )(
+      Set(
+        raw"class /\\",
+        raw"object /\\",
+        raw"method /\\",
+        raw"variable /\\",
+        raw"setter /\\_="
+      ).map(TraceEvent("typecheck", _))
+        ++ Set(
+          TraceEvent("file", if isWindows then "/.scala" else "\\\\.scala")
+        )
+    )
+  }
+
+  @Test def escapeDoubleQuotes(): Unit = {
+    val filename = "\"quoted\".scala"
+    checkTraceEvents(
+      """
+      |class `"QuotedClass"`:
+      |  var `"quotedVar"` = ???
+      |object `"QuotedObject"` {
+      |  def `"quotedMethod"` = ???
+      |}""".stripMargin,
+      filename = filename
+    ):
+      Set(
+        raw"class \"QuotedClass\"",
+        raw"object \"QuotedObject\"",
+        raw"method \"quotedMethod\"",
+        raw"variable \"quotedVar\""
+      ).map(TraceEvent("typecheck", _))
+        ++ Set(TraceEvent("file", "\\\"quoted\\\".scala"))
+  }
+  @Test def escapeNonAscii(): Unit = {
+    val filename = "unic😀de.scala"
+    checkTraceEvents(
+      """
+      |class ΩUnicodeClass:
+      |  var `中文Var` = ???
+      |object ΩUnicodeObject {
+      |  def 中文Method = ???
+      |}""".stripMargin,
+      filename = filename
+    ):
+      Set(
+        "class \\u03A9UnicodeClass",
+        "object \\u03A9UnicodeObject",
+        "method \\u4E2D\\u6587Method",
+        "variable \\u4E2D\\u6587Var"
+      ).map(TraceEvent("typecheck", _))
+        ++ Set(TraceEvent("file", "unic\\uD83D\\uDE00de.scala"))
+  }
+
+  case class TraceEvent(category: String, name: String)
+  private def compileWithTracer(
+      code: String,
+      filename: String,
+      afterPhase: String = "typer"
+  )(checkEvents: Seq[TraceEvent] => Unit) = {
+    val runCtx = locally:
+      val source = SourceFile.virtual(filename, code)
+      val c = compilerWithChecker(afterPhase) { (_, _) => () }
+      val run = c.newRun
+      run.compileSources(List(source))
+      run.runContext
+    assert(!runCtx.reporter.hasErrors, "compilation failed")
+    val outfile = ctx.settings.YprofileTrace.value
+    checkEvents:
+      scala.io.Source
+        .fromFile(outfile)
+        .getLines()
+        .collect:
+          case s"""${_}"cat":"${category}","name":${name},"ph":${_}""" =>
+            TraceEvent(category, name.stripPrefix("\"").stripSuffix("\""))
+        .distinct.toSeq
+  }
+
+  private def checkTraceEvents(code: String, filename: String = "test")(expected: Set[TraceEvent]): Unit = {
+    compileWithTracer(code, filename = filename, afterPhase = "typer"){ events =>
+      val missing = expected.diff(events.toSet)
+      def showFound = events
+        .groupBy(_.category)
+        .collect:
+          case (category, events)
+              if expected.exists(_.category == category) =>
+            s"- $category: [${events.map(_.name).mkString(", ")}]"
+        .mkString("\n")
+      assert(
+        missing.isEmpty,
+        s"""Missing ${missing.size} names [${missing.mkString(", ")}] in events, got:\n${showFound}"""
+      )
+    }
+  }
+}

From 19c945b9d938ed62073d8373c18e7acfef8ab2d7 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Fri, 1 Nov 2024 13:35:11 +0000
Subject: [PATCH 101/306] Fix provablyDisjoint handling enum constants with
 mixins

---
 .../dotty/tools/dotc/core/TypeComparer.scala    |  7 ++++---
 tests/warn/i21860.scala                         | 16 ++++++++++++++++
 tests/warn/i21860.unenum.scala                  | 17 +++++++++++++++++
 3 files changed, 37 insertions(+), 3 deletions(-)
 create mode 100644 tests/warn/i21860.scala
 create mode 100644 tests/warn/i21860.unenum.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 145a038dd856..16637c3286c1 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -3196,9 +3196,10 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       cls.is(Sealed) && !cls.hasAnonymousChild
 
     def decompose(cls: Symbol): List[Symbol] =
-      cls.children.map { child =>
-        if child.isTerm then child.info.classSymbol
-        else child
+      cls.children.flatMap { child =>
+        if child.isTerm then
+          child.info.classSymbols // allow enum vals to be decomposed to their enum class (then filtered out) and any mixins
+        else child :: Nil
       }.filter(child => child.exists && child != cls)
 
     def eitherDerivesFromOther(cls1: Symbol, cls2: Symbol): Boolean =
diff --git a/tests/warn/i21860.scala b/tests/warn/i21860.scala
new file mode 100644
index 000000000000..377d4761e80f
--- /dev/null
+++ b/tests/warn/i21860.scala
@@ -0,0 +1,16 @@
+trait Figure
+sealed trait Corners { self: Figure => }
+
+enum Shape extends Figure:
+  case Triangle extends Shape with Corners
+  case Square   extends Shape with Corners
+  case Circle   extends Shape
+  case Ellipsis extends Shape
+
+def hasCorners(s: Shape): Boolean = s match
+  case hasCorners: Corners => true //  <--- reported as `Unreachable case`
+  case _                   => false
+
+class Test:
+  def test(): Unit =
+    println(hasCorners(Shape.Circle))
diff --git a/tests/warn/i21860.unenum.scala b/tests/warn/i21860.unenum.scala
new file mode 100644
index 000000000000..7335e1b6851d
--- /dev/null
+++ b/tests/warn/i21860.unenum.scala
@@ -0,0 +1,17 @@
+trait Figure
+sealed trait Corners { self: Figure => }
+
+sealed abstract class Shape extends Figure
+object Shape:
+  case object Triange  extends Shape with Corners
+  case object Square   extends Shape with Corners
+  case object Circle   extends Shape
+  case object Ellipsis extends Shape
+
+def hasCorners(s: Shape): Boolean = s match
+  case hasCorners: Corners => true //  <--- reported as `Unreachable case`
+  case _                   => false
+
+class Test:
+  def test(): Unit =
+    println(hasCorners(Shape.Circle))

From 49d876a87851b78a63f3027811b41791a2fe583c Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Sat, 2 Nov 2024 18:09:27 +0000
Subject: [PATCH 102/306] Add extra isInstanceOf test cases

---
 tests/pos/i21544.scala | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tests/pos/i21544.scala b/tests/pos/i21544.scala
index 08a3911e4412..b2d978ea7d02 100644
--- a/tests/pos/i21544.scala
+++ b/tests/pos/i21544.scala
@@ -2,3 +2,12 @@ class Test():
   def m1(xs: List[Boolean]) = for (x: Any) <- xs yield x
   def m2(xs: List[Boolean]) = for (x: AnyVal) <- xs yield x
   def m3(xs: List[Boolean]) = for (x: Matchable) <- xs yield x
+
+  def v1(xs: List[AnyVal])    = for (x: Any) <- xs yield x
+  def v2(xs: List[AnyVal])    = for (x: AnyVal) <- xs yield x
+  def v3(xs: List[AnyVal])    = for (x: Matchable) <- xs yield x
+
+  def t1(xs: List[Matchable]) = for (x: Any) <- xs yield x
+  def t2(xs: List[Matchable]) = for (x: Matchable) <- xs yield x
+
+  def a1(xs: List[Any])       = for (x: Any) <- xs yield x

From c5cfa0abc348fe2772a36e98c03254e2c8e4fb83 Mon Sep 17 00:00:00 2001
From: HarrisL2 <harris.yh.lau@gmail.com>
Date: Mon, 28 Oct 2024 16:09:29 -0400
Subject: [PATCH 103/306] Fix warning message for matching on redundant nulls

---
 .../tools/dotc/transform/patmat/Space.scala   | 14 ++++-
 tests/warn/redundant-null.check               | 52 +++++++++++++++++++
 tests/warn/redundant-null.scala               | 41 +++++++++++++++
 3 files changed, 105 insertions(+), 2 deletions(-)
 create mode 100644 tests/warn/redundant-null.check
 create mode 100644 tests/warn/redundant-null.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index cb4dfba957a2..cf4b96a52c50 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -923,6 +923,12 @@ object SpaceEngine {
     && !sel.tpe.widen.isRef(defn.QuotedExprClass)
     && !sel.tpe.widen.isRef(defn.QuotedTypeClass)
 
+  def mayCoverNull(tp: Space)(using Context): Boolean = tp match
+    case Empty => false
+    case Prod(_, _, _) => false
+    case Typ(tp, decomposed) => tp == ConstantType(Constant(null)) 
+    case Or(ss) => ss.exists(mayCoverNull)
+
   def checkReachability(m: Match)(using Context): Unit = trace(i"checkReachability($m)"):
     val selTyp = toUnderlying(m.selector.tpe).dealias
     val isNullable = selTyp.isInstanceOf[FlexibleType] || selTyp.classSymbol.isNullableClass
@@ -948,12 +954,16 @@ object SpaceEngine {
                 && !pat.symbol.isAllOf(SyntheticCase, butNot=Method) // ExpandSAMs default cases use SyntheticCase
                 && isSubspace(covered, prev)
             then
-              val nullOnly = isNullable && rest.isEmpty && isWildcardArg(pat)
+              val nullOnly = isNullable && isWildcardArg(pat) && !mayCoverNull(prev)
               val msg = if nullOnly then MatchCaseOnlyNullWarning() else MatchCaseUnreachable()
               report.warning(msg, pat.srcPos)
 
             // in redundancy check, take guard as false in order to soundly approximate
-            val newPrev = if guard.isEmpty then covered :: prevs else prevs
+            val newPrev = if (guard.isEmpty)
+              then if (isWildcardArg(pat)) 
+                then Typ(ConstantType(Constant(null))) :: covered :: prevs
+                else covered :: prevs
+              else prevs
             recur(rest, newPrev, Nil)
 
     recur(m.cases, Nil, Nil)
diff --git a/tests/warn/redundant-null.check b/tests/warn/redundant-null.check
new file mode 100644
index 000000000000..7fdfbc1718fc
--- /dev/null
+++ b/tests/warn/redundant-null.check
@@ -0,0 +1,52 @@
+-- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:10:7 -----------------------------------------
+10 |  case _: n.type => // warn
+   |       ^^^^^^^^^
+   |       Unreachable case
+-- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:12:7 -----------------------------------------
+12 |  case _ => // warn
+   |       ^
+   |       Unreachable case
+-- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:13:7 -----------------------------------------
+13 |  case _ => // warn
+   |       ^
+   |       Unreachable case
+-- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:18:7 -----------------------------------------
+18 |  case _ => 3 // warn
+   |       ^
+   |       Unreachable case
+-- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:23:7 -----------------------------------------
+23 |  case _: B => // warn
+   |       ^^^^
+   |       Unreachable case
+-- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:24:7 -----------------------------------------
+24 |  case _ => // warn
+   |       ^
+   |       Unreachable case
+-- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:25:7 -----------------------------------------
+25 |  case null => // warn
+   |       ^^^^
+   |       Unreachable case
+-- [E121] Pattern Match Warning: tests/warn/redundant-null.scala:30:7 --------------------------------------------------
+30 |  case _ => // warn
+   |       ^
+   |       Unreachable case except for null (if this is intentional, consider writing case null => instead).
+-- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:31:7 -----------------------------------------
+31 |  case null => // warn
+   |       ^^^^
+   |       Unreachable case
+-- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:32:7 -----------------------------------------
+32 |  case _ => // warn
+   |       ^
+   |       Unreachable case
+-- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:33:7 -----------------------------------------
+33 |  case _ => // warn
+   |       ^
+   |       Unreachable case
+-- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:37:7 -----------------------------------------
+37 |  case _ => println("unreachable") // warn
+   |       ^
+   |       Unreachable case
+-- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:41:7 -----------------------------------------
+41 |  case _ => // warn
+   |       ^
+   |       Unreachable case
diff --git a/tests/warn/redundant-null.scala b/tests/warn/redundant-null.scala
new file mode 100644
index 000000000000..17da3e88350e
--- /dev/null
+++ b/tests/warn/redundant-null.scala
@@ -0,0 +1,41 @@
+class A
+class B
+class C
+
+val n = null
+
+def f(s: A) = s match
+  case _: n.type =>
+  case _: A =>
+  case _: n.type => // warn
+  case null =>
+  case _ => // warn
+  case _ => // warn
+
+def f2(s: A | B | C) = s match
+  case _: A => 0
+  case _: C | null | _: B => 1
+  case _ => 3 // warn
+
+def f3(s: A | B) = s match
+  case _: A =>
+  case _ =>
+  case _: B => // warn
+  case _ => // warn
+  case null => // warn
+
+def f4(s: String | Int) = s match
+  case _: Int =>
+  case _: String =>
+  case _ => // warn
+  case null => // warn
+  case _ => // warn
+  case _ => // warn
+
+def f5(x: String) = x match
+  case x => println("catch all")
+  case _ => println("unreachable") // warn
+
+def test(s: String | Null) = s match    
+  case ss => 
+  case _ => // warn
\ No newline at end of file

From 59173cdee428bff8db8e1c6b115fd3fc11bdab37 Mon Sep 17 00:00:00 2001
From: HarrisL2 <harris.yh.lau@gmail.com>
Date: Mon, 28 Oct 2024 18:05:05 -0400
Subject: [PATCH 104/306] Fix checkfile

---
 tests/patmat/null.check | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/patmat/null.check b/tests/patmat/null.check
index d9c265adf377..f539a921e814 100644
--- a/tests/patmat/null.check
+++ b/tests/patmat/null.check
@@ -1,3 +1,3 @@
-6: Pattern Match
+6: Match case Unreachable
 13: Pattern Match
 20: Pattern Match

From 158c1df94e98f9f3ee61106103b367d5c00d259b Mon Sep 17 00:00:00 2001
From: HarrisL2 <harris.yh.lau@gmail.com>
Date: Fri, 1 Nov 2024 15:06:59 -0400
Subject: [PATCH 105/306] Change projection approach

---
 .../tools/dotc/transform/patmat/Space.scala   | 32 +++++++++----------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index cf4b96a52c50..463bf767a442 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -937,36 +937,36 @@ object SpaceEngine {
       then project(OrType(selTyp, ConstantType(Constant(null)), soft = false))
       else project(selTyp)
 
-    @tailrec def recur(cases: List[CaseDef], prevs: List[Space], deferred: List[Tree]): Unit =
+    @tailrec def recur(cases: List[CaseDef], prevs: List[Space], deferred: List[Tree], nullCovered: Boolean): Unit =
       cases match
         case Nil =>
-        case CaseDef(pat, guard, _) :: rest =>
-          val curr = trace(i"project($pat)")(project(pat))
+        case (c @ CaseDef(pat, guard, _)) :: rest =>
+          val patNullable = Nullables.matchesNull(c)
+          val curr = trace(i"project($pat)")(
+            if patNullable
+            then Or(List(project(pat), Typ(ConstantType(Constant(null)))))
+            else project(pat))
           val covered = trace("covered")(simplify(intersect(curr, targetSpace)))
           val prev = trace("prev")(simplify(Or(prevs)))
           if prev == Empty && covered == Empty then // defer until a case is reachable
-            recur(rest, prevs, pat :: deferred)
+            recur(rest, prevs, pat :: deferred, nullCovered)
           else
             for pat <- deferred.reverseIterator
             do report.warning(MatchCaseUnreachable(), pat.srcPos)
 
             if pat != EmptyTree // rethrow case of catch uses EmptyTree
                 && !pat.symbol.isAllOf(SyntheticCase, butNot=Method) // ExpandSAMs default cases use SyntheticCase
-                && isSubspace(covered, prev)
+                && isSubspace(covered, Or(List(prev, Typ(ConstantType(Constant(null))))))
             then
-              val nullOnly = isNullable && isWildcardArg(pat) && !mayCoverNull(prev)
-              val msg = if nullOnly then MatchCaseOnlyNullWarning() else MatchCaseUnreachable()
-              report.warning(msg, pat.srcPos)
+              val nullOnly = isNullable && isWildcardArg(pat) && !nullCovered && !isSubspace(covered, prev) && (!ctx.explicitNulls || selTyp.isInstanceOf[FlexibleType])
+              if nullOnly then report.warning(MatchCaseOnlyNullWarning() , pat.srcPos)
+              else if (isSubspace(covered, prev)) then report.warning(MatchCaseUnreachable(), pat.srcPos)
 
             // in redundancy check, take guard as false in order to soundly approximate
-            val newPrev = if (guard.isEmpty)
-              then if (isWildcardArg(pat)) 
-                then Typ(ConstantType(Constant(null))) :: covered :: prevs
-                else covered :: prevs
-              else prevs
-            recur(rest, newPrev, Nil)
-
-    recur(m.cases, Nil, Nil)
+            val newPrev = if (guard.isEmpty) then covered :: prevs else prevs
+            recur(rest, newPrev, Nil, nullCovered || (guard.isEmpty && patNullable))
+
+    recur(m.cases, Nil, Nil, false)
   end checkReachability
 
   def checkMatch(m: Match)(using Context): Unit =

From 17cd9aa644beaf8fb99163c5a06e9772bc1abf62 Mon Sep 17 00:00:00 2001
From: HarrisL2 <harris.yh.lau@gmail.com>
Date: Mon, 4 Nov 2024 11:59:14 -0500
Subject: [PATCH 106/306] Add suggested changes

---
 .../tools/dotc/transform/patmat/Space.scala   | 52 +++++++++++--------
 tests/explicit-nulls/warn/i21577.check        | 14 +++--
 tests/explicit-nulls/warn/i21577.scala        | 12 ++---
 tests/patmat/null.check                       |  2 +-
 tests/warn/i20121.scala                       |  4 +-
 tests/warn/i20122.scala                       |  2 +-
 tests/warn/i20123.scala                       |  2 +-
 tests/warn/redundant-null.check               | 30 ++++++-----
 tests/warn/redundant-null.scala               | 32 +++++++-----
 9 files changed, 84 insertions(+), 66 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 463bf767a442..7410d617c4a0 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -116,6 +116,7 @@ object SpaceEngine {
   def isSubspace(a: Space, b: Space)(using Context): Boolean = a.isSubspace(b)
   def canDecompose(typ: Typ)(using Context): Boolean         = typ.canDecompose
   def decompose(typ: Typ)(using Context): List[Typ]          = typ.decompose
+  def nullSpace(using Context): Space = Typ(ConstantType(Constant(null)), decomposed = false)
 
   /** Simplify space such that a space equal to `Empty` becomes `Empty` */
   def computeSimplify(space: Space)(using Context): Space = trace(i"simplify($space)")(space match {
@@ -336,6 +337,13 @@ object SpaceEngine {
     case pat: Ident if isBackquoted(pat) =>
       Typ(pat.tpe, decomposed = false)
 
+    case Ident(nme.WILDCARD) =>
+      val tp = pat.tpe.stripAnnots.widenSkolem
+      val isNullable = tp.isInstanceOf[FlexibleType] || tp.classSymbol.isNullableClass
+      val tpSpace = Typ(erase(tp, isValue = true), decomposed = false)
+      if isNullable then Or(tpSpace :: nullSpace :: Nil)
+      else tpSpace
+
     case Ident(_) | Select(_, _) =>
       Typ(erase(pat.tpe.stripAnnots.widenSkolem, isValue = true), decomposed = false)
 
@@ -667,7 +675,7 @@ object SpaceEngine {
           case tp                                                          => (tp, Nil)
         val (tp, typeArgs) = getAppliedClass(tpOriginal)
         // This function is needed to get the arguments of the types that will be applied to the class.
-        // This is necessary because if the arguments of the types contain Nothing, 
+        // This is necessary because if the arguments of the types contain Nothing,
         // then this can affect whether the class will be taken into account during the exhaustiveness check
         def getTypeArgs(parent: Symbol, child: Symbol, typeArgs: List[Type]): List[Type] =
           val superType = child.typeRef.superType
@@ -923,12 +931,6 @@ object SpaceEngine {
     && !sel.tpe.widen.isRef(defn.QuotedExprClass)
     && !sel.tpe.widen.isRef(defn.QuotedTypeClass)
 
-  def mayCoverNull(tp: Space)(using Context): Boolean = tp match
-    case Empty => false
-    case Prod(_, _, _) => false
-    case Typ(tp, decomposed) => tp == ConstantType(Constant(null)) 
-    case Or(ss) => ss.exists(mayCoverNull)
-
   def checkReachability(m: Match)(using Context): Unit = trace(i"checkReachability($m)"):
     val selTyp = toUnderlying(m.selector.tpe).dealias
     val isNullable = selTyp.isInstanceOf[FlexibleType] || selTyp.classSymbol.isNullableClass
@@ -936,37 +938,41 @@ object SpaceEngine {
       if isNullable && !ctx.mode.is(Mode.SafeNulls)
       then project(OrType(selTyp, ConstantType(Constant(null)), soft = false))
       else project(selTyp)
-
-    @tailrec def recur(cases: List[CaseDef], prevs: List[Space], deferred: List[Tree], nullCovered: Boolean): Unit =
+    var hadNullOnly = false
+    @tailrec def recur(cases: List[CaseDef], prevs: List[Space], deferred: List[Tree]): Unit =
       cases match
         case Nil =>
-        case (c @ CaseDef(pat, guard, _)) :: rest =>
-          val patNullable = Nullables.matchesNull(c)
-          val curr = trace(i"project($pat)")(
-            if patNullable
-            then Or(List(project(pat), Typ(ConstantType(Constant(null)))))
-            else project(pat))
+        case CaseDef(pat, guard, _) :: rest =>
+          val curr = trace(i"project($pat)")(project(pat))
           val covered = trace("covered")(simplify(intersect(curr, targetSpace)))
           val prev = trace("prev")(simplify(Or(prevs)))
           if prev == Empty && covered == Empty then // defer until a case is reachable
-            recur(rest, prevs, pat :: deferred, nullCovered)
+            recur(rest, prevs, pat :: deferred)
           else
             for pat <- deferred.reverseIterator
             do report.warning(MatchCaseUnreachable(), pat.srcPos)
 
             if pat != EmptyTree // rethrow case of catch uses EmptyTree
                 && !pat.symbol.isAllOf(SyntheticCase, butNot=Method) // ExpandSAMs default cases use SyntheticCase
-                && isSubspace(covered, Or(List(prev, Typ(ConstantType(Constant(null))))))
             then
-              val nullOnly = isNullable && isWildcardArg(pat) && !nullCovered && !isSubspace(covered, prev) && (!ctx.explicitNulls || selTyp.isInstanceOf[FlexibleType])
-              if nullOnly then report.warning(MatchCaseOnlyNullWarning() , pat.srcPos)
-              else if (isSubspace(covered, prev)) then report.warning(MatchCaseUnreachable(), pat.srcPos)
+              if isSubspace(covered, prev) then
+                report.warning(MatchCaseUnreachable(), pat.srcPos)
+              else if isNullable && !hadNullOnly && isWildcardArg(pat)
+                && isSubspace(covered, Or(prev :: nullSpace :: Nil)) then
+                // Issue OnlyNull warning only if:
+                // 1. The target space is nullable;
+                // 2. OnlyNull warning has not been issued before;
+                // 3. The pattern is a wildcard pattern;
+                // 4. The pattern is not covered by the previous cases,
+                //    but covered by the previous cases with null.
+                hadNullOnly = true
+                report.warning(MatchCaseOnlyNullWarning(), pat.srcPos)
 
             // in redundancy check, take guard as false in order to soundly approximate
-            val newPrev = if (guard.isEmpty) then covered :: prevs else prevs
-            recur(rest, newPrev, Nil, nullCovered || (guard.isEmpty && patNullable))
+            val newPrev = if guard.isEmpty then covered :: prevs else prevs
+            recur(rest, newPrev, Nil)
 
-    recur(m.cases, Nil, Nil, false)
+    recur(m.cases, Nil, Nil)
   end checkReachability
 
   def checkMatch(m: Match)(using Context): Unit =
diff --git a/tests/explicit-nulls/warn/i21577.check b/tests/explicit-nulls/warn/i21577.check
index acedd7a9c713..b548a5bedc30 100644
--- a/tests/explicit-nulls/warn/i21577.check
+++ b/tests/explicit-nulls/warn/i21577.check
@@ -1,17 +1,21 @@
 -- [E121] Pattern Match Warning: tests/explicit-nulls/warn/i21577.scala:5:9 --------------------------------------------
-5 |    case _ => // warn
+5 |    case _ => // warn: null only
   |         ^
   |         Unreachable case except for null (if this is intentional, consider writing case null => instead).
 -- [E121] Pattern Match Warning: tests/explicit-nulls/warn/i21577.scala:12:9 -------------------------------------------
-12 |    case _ => // warn
+12 |    case _ => // warn: null only
    |         ^
    |         Unreachable case except for null (if this is intentional, consider writing case null => instead).
+-- [E121] Pattern Match Warning: tests/explicit-nulls/warn/i21577.scala:16:7 -------------------------------------------
+16 |  case _ => // warn: null only
+   |       ^
+   |       Unreachable case except for null (if this is intentional, consider writing case null => instead).
 -- [E030] Match case Unreachable Warning: tests/explicit-nulls/warn/i21577.scala:20:7 ----------------------------------
-20 |  case _ => // warn
+20 |  case _ => // warn: unreachable
    |       ^
    |       Unreachable case
 -- [E029] Pattern Match Exhaustivity Warning: tests/explicit-nulls/warn/i21577.scala:29:27 -----------------------------
-29 |def f7(s: String | Null) = s match // warn
+29 |def f7(s: String | Null) = s match // warn: not exhuastive
    |                           ^
    |                           match may not be exhaustive.
    |
@@ -19,7 +23,7 @@
    |
    | longer explanation available when compiling with `-explain`
 -- [E029] Pattern Match Exhaustivity Warning: tests/explicit-nulls/warn/i21577.scala:36:33 -----------------------------
-36 |def f9(s: String | Int | Null) = s match // warn
+36 |def f9(s: String | Int | Null) = s match // warn: not exhuastive
    |                                 ^
    |                                 match may not be exhaustive.
    |
diff --git a/tests/explicit-nulls/warn/i21577.scala b/tests/explicit-nulls/warn/i21577.scala
index 67da6068f22c..1bba8f4da01f 100644
--- a/tests/explicit-nulls/warn/i21577.scala
+++ b/tests/explicit-nulls/warn/i21577.scala
@@ -2,22 +2,22 @@ def f(s: String) =
   val s2 = s.trim()
   s2 match
     case s3: String =>
-    case _ => // warn
+    case _ => // warn: null only
 
 
 def f2(s: String | Null) =
   val s2 = s.nn.trim()
   s2 match
     case s3: String =>
-    case _ => // warn
+    case _ => // warn: null only
 
 def f3(s: String | Null) = s match
   case s2: String =>
-  case _ =>
+  case _ => // warn: null only
 
 def f5(s: String) = s match
   case _: String =>
-  case _ => // warn
+  case _ => // warn: unreachable
 
 def f6(s: String) = s.trim() match
   case _: String =>
@@ -26,13 +26,13 @@ def f6(s: String) = s.trim() match
 def f61(s: String) = s.trim() match
   case _: String =>
 
-def f7(s: String | Null) = s match // warn
+def f7(s: String | Null) = s match // warn: not exhuastive
   case _: String =>
 
 def f8(s: String | Null) = s match
   case _: String =>
   case null =>
 
-def f9(s: String | Int | Null) = s match // warn
+def f9(s: String | Int | Null) = s match // warn: not exhuastive
   case _: String =>
   case null =>
\ No newline at end of file
diff --git a/tests/patmat/null.check b/tests/patmat/null.check
index f539a921e814..d9c265adf377 100644
--- a/tests/patmat/null.check
+++ b/tests/patmat/null.check
@@ -1,3 +1,3 @@
-6: Match case Unreachable
+6: Pattern Match
 13: Pattern Match
 20: Pattern Match
diff --git a/tests/warn/i20121.scala b/tests/warn/i20121.scala
index ce8e3e4d74f6..b8402fa808ac 100644
--- a/tests/warn/i20121.scala
+++ b/tests/warn/i20121.scala
@@ -5,8 +5,8 @@ case class CC_B[A](a: A) extends T_A[A, X]
 
 val v_a: T_A[X, X] = CC_B(null)
 val v_b = v_a match
-  case CC_B(_) => 0 // warn: unreachable
-  case _       => 1
+  case CC_B(_) => 0
+  case _       => 1 // warn: null only
     // for CC_B[A] to match T_A[X, X]
     // A := X
     // so require X, aka T_A[Byte, Byte]
diff --git a/tests/warn/i20122.scala b/tests/warn/i20122.scala
index 50da42a5926c..d035a18d3b09 100644
--- a/tests/warn/i20122.scala
+++ b/tests/warn/i20122.scala
@@ -7,7 +7,7 @@ case class CC_E(a: CC_C[Char, Byte])
 
 val v_a: T_B[Int, CC_A] = CC_B(CC_E(CC_C(null)))
 val v_b = v_a match
-  case CC_B(CC_E(CC_C(_))) => 0 // warn: unreachable
+  case CC_B(CC_E(CC_C(_))) => 0
   case _                   => 1
     // for CC_B[A, C] to match T_B[C, CC_A]
     // C <: Int, ok
diff --git a/tests/warn/i20123.scala b/tests/warn/i20123.scala
index 32de903210b2..0af7aba5a3a5 100644
--- a/tests/warn/i20123.scala
+++ b/tests/warn/i20123.scala
@@ -8,7 +8,7 @@ case class CC_G[A, C](c: C) extends T_A[A, C]
 val v_a: T_A[Boolean, T_B[Boolean]] = CC_G(null)
 val v_b = v_a match {
   case CC_D()  => 0
-  case CC_G(_) => 1 // warn: unreachable
+  case CC_G(_) => 1
     // for CC_G[A, C] to match T_A[Boolean, T_B[Boolean]]
     // A := Boolean, which is ok
     // C := T_B[Boolean],
diff --git a/tests/warn/redundant-null.check b/tests/warn/redundant-null.check
index 7fdfbc1718fc..9d710e18961d 100644
--- a/tests/warn/redundant-null.check
+++ b/tests/warn/redundant-null.check
@@ -1,52 +1,56 @@
 -- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:10:7 -----------------------------------------
-10 |  case _: n.type => // warn
+10 |  case _: n.type => // warn: unreachable
    |       ^^^^^^^^^
    |       Unreachable case
 -- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:12:7 -----------------------------------------
-12 |  case _ => // warn
+12 |  case _ => // warn: unreachable
    |       ^
    |       Unreachable case
 -- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:13:7 -----------------------------------------
-13 |  case _ => // warn
+13 |  case _ => // warn: unreachable
    |       ^
    |       Unreachable case
 -- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:18:7 -----------------------------------------
-18 |  case _ => 3 // warn
+18 |  case _ => 3 // warn: unreachable
    |       ^
    |       Unreachable case
 -- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:23:7 -----------------------------------------
-23 |  case _: B => // warn
+23 |  case _: B => // warn: unreachable
    |       ^^^^
    |       Unreachable case
 -- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:24:7 -----------------------------------------
-24 |  case _ => // warn
+24 |  case _ => // warn: unreachable
    |       ^
    |       Unreachable case
 -- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:25:7 -----------------------------------------
-25 |  case null => // warn
+25 |  case null => // warn: unreachable
    |       ^^^^
    |       Unreachable case
 -- [E121] Pattern Match Warning: tests/warn/redundant-null.scala:30:7 --------------------------------------------------
-30 |  case _ => // warn
+30 |  case _ => // warn: null only
    |       ^
    |       Unreachable case except for null (if this is intentional, consider writing case null => instead).
 -- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:31:7 -----------------------------------------
-31 |  case null => // warn
+31 |  case null => // warn: unreachable
    |       ^^^^
    |       Unreachable case
 -- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:32:7 -----------------------------------------
-32 |  case _ => // warn
+32 |  case _ => // warn: unreachable
    |       ^
    |       Unreachable case
 -- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:33:7 -----------------------------------------
-33 |  case _ => // warn
+33 |  case _ => // warn: unreachable
    |       ^
    |       Unreachable case
 -- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:37:7 -----------------------------------------
-37 |  case _ => println("unreachable") // warn
+37 |  case _ => // warn: unreachable
    |       ^
    |       Unreachable case
 -- [E030] Match case Unreachable Warning: tests/warn/redundant-null.scala:41:7 -----------------------------------------
-41 |  case _ => // warn
+41 |  case _ => // warn: unreachable
    |       ^
    |       Unreachable case
+-- [E121] Pattern Match Warning: tests/warn/redundant-null.scala:45:7 --------------------------------------------------
+45 |  case _ => // warn: null only
+   |       ^
+   |       Unreachable case except for null (if this is intentional, consider writing case null => instead).
diff --git a/tests/warn/redundant-null.scala b/tests/warn/redundant-null.scala
index 17da3e88350e..ec0096d78daf 100644
--- a/tests/warn/redundant-null.scala
+++ b/tests/warn/redundant-null.scala
@@ -7,35 +7,39 @@ val n = null
 def f(s: A) = s match
   case _: n.type =>
   case _: A =>
-  case _: n.type => // warn
+  case _: n.type => // warn: unreachable
   case null =>
-  case _ => // warn
-  case _ => // warn
+  case _ => // warn: unreachable
+  case _ => // warn: unreachable
 
 def f2(s: A | B | C) = s match
   case _: A => 0
   case _: C | null | _: B => 1
-  case _ => 3 // warn
+  case _ => 3 // warn: unreachable
 
 def f3(s: A | B) = s match
   case _: A =>
   case _ =>
-  case _: B => // warn
-  case _ => // warn
-  case null => // warn
+  case _: B => // warn: unreachable
+  case _ => // warn: unreachable
+  case null => // warn: unreachable
 
 def f4(s: String | Int) = s match
   case _: Int =>
   case _: String =>
-  case _ => // warn
-  case null => // warn
-  case _ => // warn
-  case _ => // warn
+  case _ => // warn: null only
+  case null => // warn: unreachable
+  case _ => // warn: unreachable
+  case _ => // warn: unreachable
 
 def f5(x: String) = x match
-  case x => println("catch all")
-  case _ => println("unreachable") // warn
+  case x =>
+  case _ => // warn: unreachable
 
 def test(s: String | Null) = s match    
   case ss => 
-  case _ => // warn
\ No newline at end of file
+  case _ => // warn: unreachable
+
+def test2(s: String | Null) = s match    
+  case ss: String => 
+  case _ => // warn: null only
\ No newline at end of file

From 0800e0feaa0ee7e877d8c19ad0abfca1fd507cf6 Mon Sep 17 00:00:00 2001
From: HarrisL2 <harris.yh.lau@gmail.com>
Date: Mon, 4 Nov 2024 12:32:04 -0500
Subject: [PATCH 107/306] Fix null wildcard in SymbolLoaders

---
 compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala b/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
index 5690720a1b3f..becfcdb5861c 100644
--- a/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
@@ -337,7 +337,7 @@ abstract class SymbolLoader extends LazyType { self =>
     val sym = root.symbol
     def associatedFile = root.symbol.associatedFile match
       case file: AbstractFile => file
-      case _ => NoAbstractFile
+      case null => NoAbstractFile
     ctx.profiler.onCompletion(sym, associatedFile)(body)
   }
 

From 1b48966b0097473930f2b02a41f66c10448a5839 Mon Sep 17 00:00:00 2001
From: HarrisL2 <harris.yh.lau@gmail.com>
Date: Tue, 5 Nov 2024 00:42:17 -0500
Subject: [PATCH 108/306] Fix patmat test output

---
 tests/patmat/i12530.check | 1 -
 tests/patmat/null.check   | 3 ++-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/patmat/i12530.check b/tests/patmat/i12530.check
index 636347516cbc..b0605bcd95e5 100644
--- a/tests/patmat/i12530.check
+++ b/tests/patmat/i12530.check
@@ -1,2 +1 @@
 6: Match case Unreachable
-14: Match case Unreachable
diff --git a/tests/patmat/null.check b/tests/patmat/null.check
index d9c265adf377..da081e6b56c0 100644
--- a/tests/patmat/null.check
+++ b/tests/patmat/null.check
@@ -1,3 +1,4 @@
-6: Pattern Match
+6: Match case Unreachable
 13: Pattern Match
+18: Match case Unreachable
 20: Pattern Match

From 14e46e845d0775538253560c599c1b43c3bfb880 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 5 Nov 2024 10:15:24 +0000
Subject: [PATCH 109/306] Push java inner class privateWithin setting

---
 .../dotty/tools/dotc/core/SymbolLoaders.scala | 20 ++++++++++++-------
 .../dotc/core/classfile/ClassfileParser.scala | 17 +++++++---------
 2 files changed, 20 insertions(+), 17 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala b/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
index 585db8488a78..0f01a687f905 100644
--- a/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
@@ -51,8 +51,9 @@ object SymbolLoaders {
    */
   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, compUnitInfo = completer.compilationUnitInfo)
+      flags: FlagSet = EmptyFlags, scope: Scope = EmptyScope, privateWithin: Symbol = NoSymbol,
+  )(using Context): Symbol = {
+    val cls = newClassSymbol(owner, name.toTypeName.unmangleClassName.decode, flags, completer, privateWithin, compUnitInfo = completer.compilationUnitInfo)
     enterNew(owner, cls, completer, scope)
   }
 
@@ -60,10 +61,13 @@ object SymbolLoaders {
    */
   def enterModule(
       owner: Symbol, name: PreName, completer: SymbolLoader,
-      modFlags: FlagSet = EmptyFlags, clsFlags: FlagSet = EmptyFlags, scope: Scope = EmptyScope)(using Context): Symbol = {
+      modFlags: FlagSet = EmptyFlags, clsFlags: FlagSet = EmptyFlags,
+      scope: Scope = EmptyScope, privateWithin: Symbol = NoSymbol,
+  )(using Context): Symbol = {
     val module = newModuleSymbol(
       owner, name.toTermName.decode, modFlags, clsFlags,
       (module, _) => completer.proxy.withDecls(newScope).withSourceModule(module),
+      privateWithin,
       compUnitInfo = completer.compilationUnitInfo)
     enterNew(owner, module, completer, scope)
     enterNew(owner, module.moduleClass, completer, scope)
@@ -103,14 +107,16 @@ object SymbolLoaders {
    */
   def enterClassAndModule(
       owner: Symbol, name: PreName, completer: SymbolLoader,
-      flags: FlagSet = EmptyFlags, scope: Scope = EmptyScope)(using Context): (Symbol, Symbol) = {
-    val clazz = enterClass(owner, name, completer, flags, scope)
+      flags: FlagSet = EmptyFlags, scope: Scope = EmptyScope, privateWithin: Symbol = NoSymbol,
+  )(using Context): Unit = {
+    val clazz = enterClass(owner, name, completer, flags, scope, privateWithin)
     val module = enterModule(
       owner, name, completer,
       modFlags = flags.toTermFlags & RetainedModuleValFlags,
       clsFlags = flags.toTypeFlags & RetainedModuleClassFlags,
-      scope = scope)
-    (clazz, module)
+      scope = scope,
+      privateWithin = privateWithin,
+    )
   }
 
   /** Enter all toplevel classes and objects in file `src` into package `owner`, provided
diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
index 4b0dec2c88b7..3af0fc6603d5 100644
--- a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
+++ b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
@@ -1059,17 +1059,14 @@ class ClassfileParser(
    */
   private def enterOwnInnerClasses()(using Context, DataReader): Unit = {
     def enterClassAndModule(entry: InnerClassEntry, file: AbstractFile, jflags: Int) =
-      val (cls, mod) = SymbolLoaders.enterClassAndModule(
-          getOwner(jflags),
+      SymbolLoaders.enterClassAndModule(
+        getOwner(jflags),
         entry.originalName,
-          new ClassfileLoader(file),
-          classTranslation.flags(jflags),
-          getScope(jflags))
-
-      val privateWithin = getPrivateWithin(jflags)
-      cls.setPrivateWithin(privateWithin)
-      mod.setPrivateWithin(privateWithin)
-      mod.sourceModule.setPrivateWithin(privateWithin)
+        new ClassfileLoader(file),
+        classTranslation.flags(jflags),
+        getScope(jflags),
+        getPrivateWithin(jflags),
+      )
 
     for entry <- innerClasses.valuesIterator do
       // create a new class member for immediate inner classes

From 7f47867a824f3fd38aed63eaedfa4f4d339cbd99 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Tue, 5 Nov 2024 22:18:15 +0100
Subject: [PATCH 110/306] Don't point to the compiler backlog when a compiler
 plugin phase crashes (#21887)

closes #21783
---
 compiler/src/dotty/tools/dotc/report.scala | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/report.scala b/compiler/src/dotty/tools/dotc/report.scala
index e24e6be38b2b..2ccf918e12fa 100644
--- a/compiler/src/dotty/tools/dotc/report.scala
+++ b/compiler/src/dotty/tools/dotc/report.scala
@@ -165,13 +165,23 @@ object report:
       "compiler version"   -> dotty.tools.dotc.config.Properties.versionString,
       "settings"           -> settings.map(showSetting).mkString(" "),
     ))
+    val fileAReportMsg =
+      if ctx.phase.isInstanceOf[plugins.PluginPhase]
+      then
+        s"""|  An unhandled exception was thrown in the compiler plugin named "${ctx.phase.megaPhase}".
+            |  Please report the issue to the plugin's maintainers.
+            |  For non-enriched exceptions, compile with -Xno-enrich-error-messages.
+            |""".stripMargin
+      else
+        s"""|  An unhandled exception was thrown in the compiler.
+            |  Please file a crash report here:
+            |  https://github.com/scala/scala3/issues/new/choose
+            |  For non-enriched exceptions, compile with -Xno-enrich-error-messages.
+            |""".stripMargin
     s"""
        |  $errorMessage
        |
-       |  An unhandled exception was thrown in the compiler.
-       |  Please file a crash report here:
-       |  https://github.com/scala/scala3/issues/new/choose
-       |  For non-enriched exceptions, compile with -Xno-enrich-error-messages.
+       |$fileAReportMsg
        |
        |$info1
        |""".stripMargin

From 11c957c861dbb37f7e81d062d173175c67eca449 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Wed, 6 Nov 2024 11:16:02 +0100
Subject: [PATCH 111/306] [build] Improve, document and group versioning code
 in `Build.scala`  (#21837)

* Introduce `developedVersion` describing the target for the current
release cycle
* Adapt `baseVersion` to the effectively revert #21011 changes
* Adapt .msi packager to use `developedVersion` as a workaround to MSI
ProductInfo limitations (version without RC suffix required)
* Group and document versioning related code
---
 .github/workflows/build-msi.yml |  4 +--
 project/Build.scala             | 62 ++++++++++++++++++++-------------
 2 files changed, 40 insertions(+), 26 deletions(-)

diff --git a/.github/workflows/build-msi.yml b/.github/workflows/build-msi.yml
index 8e7cf8a9ef47..14838c589d6a 100644
--- a/.github/workflows/build-msi.yml
+++ b/.github/workflows/build-msi.yml
@@ -14,8 +14,8 @@ on:
   workflow_call:
 
 env:
-  # NECESSARY FLAG TO CORRECTLY CONFIGURE THE VERSION FOR SCALA
-  RELEASEBUILD: yes
+  # Release only happends when triggering CI by pushing tag
+  RELEASEBUILD: ${{ startsWith(github.event.ref, 'refs/tags/') && 'yes' || 'no' }}
 
 jobs:
   build:
diff --git a/project/Build.scala b/project/Build.scala
index 55f07f8bcd36..03850a5c0f0d 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -99,10 +99,39 @@ object Build {
    */
   val referenceVersion = "3.6.0"
 
-  val baseVersion = "3.6.2"
-  // Will be required by some automation later
-  // TODO: Introduce automation and handling for RC versions before 3.6.2-RC1
-  // val prereleaseVersion = s"$baseVersion-RC1"
+  /** Version of the Scala compiler targeted in the current release cycle
+   *  Contains a version without RC/SNAPSHOT/NIGHTLY specific suffixes
+   *  Should be updated ONLY after release or cutoff for previous release cycle.
+   *  
+   *  Should only be referred from `dottyVersion` or settings/tasks requiring simplified version string, 
+   *  eg. `compatMode` or Windows native distribution version.
+   */
+  val developedVersion = "3.6.2"
+
+  /** The version of the compiler including the RC prefix. 
+   *  Defined as common base before calculating environment specific suffixes in `dottyVersion`
+   * 
+   *  By default, during development cycle defined as `${developedVersion}-RC1`;
+   *  During release candidate cycle incremented by the release officer before publishing a subsequent RC version;
+   *  During final, stable release is set exactly to `developedVersion`.
+  */
+  val baseVersion = s"$developedVersion-RC1"
+
+  /** Final version of Scala compiler, controlled by environment variables. */
+  val dottyVersion = {
+    if (isRelease) baseVersion
+    else if (isNightly) s"${baseVersion}-bin-${VersionUtil.commitDate}-${VersionUtil.gitHash}-NIGHTLY"
+    else s"${baseVersion}-bin-SNAPSHOT"
+  }
+  def isRelease = sys.env.get("RELEASEBUILD").contains("yes")
+  def isNightly = sys.env.get("NIGHTLYBUILD").contains("yes")
+
+  /** Version calculate for `nonbootstrapped` projects */
+  val dottyNonBootstrappedVersion = {
+    // Make sure sbt always computes the scalaBinaryVersion correctly
+    val bin = if (!dottyVersion.contains("-bin")) "-bin" else ""
+    dottyVersion + bin + "-nonbootstrapped"
+  }
 
   // LTS or Next
   val versionLine = "Next"
@@ -117,7 +146,7 @@ object Build {
   /** Minor version against which we check binary compatibility.
    *
    *  This must be the earliest published release in the same versioning line.
-   *  For a baseVersion `3.M.P` the mimaPreviousDottyVersion should be set to:
+   *  For a developedVersion `3.M.P` the mimaPreviousDottyVersion should be set to:
    *   - `3.M.0`     if `P > 0`
    *   - `3.(M-1).0` if `P = 0`
    *  3.6.1 is an exception from this rule - 3.6.0 was a broken release
@@ -144,7 +173,7 @@ object Build {
 
   val compatMode = {
     val VersionRE = """^\d+\.(\d+)\.(\d+)""".r
-    baseVersion match {
+    developedVersion match {
       case VersionRE(_, "0")   => CompatMode.BinaryCompatible
       case _                   => CompatMode.SourceAndBinaryCompatible
     }
@@ -174,24 +203,6 @@ object Build {
   val dottyGithubUrl = "https://github.com/scala/scala3"
   val dottyGithubRawUserContentUrl = "https://raw.githubusercontent.com/scala/scala3"
 
-
-  val isRelease = sys.env.get("RELEASEBUILD") == Some("yes")
-
-  val dottyVersion = {
-    def isNightly = sys.env.get("NIGHTLYBUILD") == Some("yes")
-    if (isRelease)
-      baseVersion
-    else if (isNightly)
-      baseVersion + "-RC1-bin-" + VersionUtil.commitDate + "-" + VersionUtil.gitHash + "-NIGHTLY"
-    else
-      baseVersion + "-RC1-bin-SNAPSHOT"
-  }
-  val dottyNonBootstrappedVersion = {
-    // Make sure sbt always computes the scalaBinaryVersion correctly
-    val bin = if (!dottyVersion.contains("-bin")) "-bin" else ""
-    dottyVersion + bin + "-nonbootstrapped"
-  }
-
   val sbtCommunityBuildVersion = "0.1.0-SNAPSHOT"
 
   val agentOptions = List(
@@ -2274,6 +2285,9 @@ object Build {
     )
     .settings(
       Windows / name := "scala",
+      // Windows/version is used to create ProductInfo - it requires a version without any -RC suffixes
+      // If not explicitly overriden it would try to use `dottyVersion` assigned to `dist-win-x86_64/version`
+      Windows / version    := developedVersion,
       Windows / mappings   := (Universal / mappings).value,
       Windows / packageBin := (Windows / packageBin).dependsOn(republish).value,
       Windows / wixFiles   := (Windows / wixFiles).dependsOn(republish).value,

From c63cfde48f71af8217b7ab4e6a4ac9463b71a5f7 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Wed, 6 Nov 2024 11:26:03 +0100
Subject: [PATCH 112/306] Disable automatic release in `publish_release` 
 (#21873)

Releases of stable versions now require manual approval on
https://oss.sonatype.org/ by release officer.
Difference between `sonatypeBundleRelease` and `sonatypeBundleUpload`
is described
[here](https://github.com/xerial/sbt-sonatype?tab=readme-ov-file#commands)

[skip ci]

---------

Co-authored-by: Hamza Remmal <hamza@remmal.net>
---
 .github/workflows/ci.yaml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index ffa7e515b926..5562423720d8 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -1093,7 +1093,7 @@ jobs:
           asset_content_type: text/plain
 
       - name: Publish Release
-        run: ./project/scripts/sbtPublish ";project scala3-bootstrapped ;publishSigned ;sonatypeBundleRelease"
+        run: ./project/scripts/sbtPublish ";project scala3-bootstrapped ;publishSigned ;sonatypeBundleUpload"
 
 
   open_issue_on_failure:
@@ -1125,7 +1125,7 @@ jobs:
     needs: [build-msi-package]
     with:
       # Ensure that version starts with prefix 3.
-      # In the future it can be adapted to compare with with git tag or version set in the build.s 
+      # In the future it can be adapted to compare with with git tag or version set in the project/Build.scala
       version: "3."
       java-version: 8
 

From 0dceb7fd16e5db4df1063a77018c604f6fe741b1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= <sjrdoeraene@gmail.com>
Date: Tue, 5 Nov 2024 17:00:48 +0100
Subject: [PATCH 113/306] Fix #21295: Restrict `provablyDisjoint` with
 `Nothing`s in invariant type params.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

If `Foo[T]` is invariant in `T`, we previously concluded that
`Foo[A] ⋔ Foo[B]` from `A ⋔ B`. That is however wrong if both `A`
and `B` can be (instantiated to) `Nothing`.

We now rule out these occurrences in two ways:

* either we show that `T` corresponds to a field, like we do in the
  covariant case, or
* we show that `A` or `B` cannot possibly be `Nothing`.

The second condition is shaky at best. I would have preferred not
to include it. However, introducing the former without the fallback
on the latter breaks too many existing test cases.
---
 .../dotty/tools/dotc/core/TypeComparer.scala  | 21 +++++++++++++++++--
 tests/pos/i21295.scala                        |  8 +++++++
 2 files changed, 27 insertions(+), 2 deletions(-)
 create mode 100644 tests/pos/i21295.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 16637c3286c1..17d427513e58 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -3232,6 +3232,12 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
   end provablyDisjointClasses
 
   private def provablyDisjointTypeArgs(cls: ClassSymbol, args1: List[Type], args2: List[Type], pending: util.HashSet[(Type, Type)])(using Context): Boolean =
+    // sjrd: I will not be surprised when this causes further issues in the future.
+    // This is a compromise to be able to fix #21295 without breaking the world.
+    def cannotBeNothing(tp: Type): Boolean = tp match
+      case tp: TypeParamRef => cannotBeNothing(tp.paramInfo)
+      case _                => !(tp.loBound.stripTypeVar <:< defn.NothingType)
+
     // It is possible to conclude that two types applied are disjoint by
     // looking at covariant type parameters if the said type parameters
     // are disjoint and correspond to fields.
@@ -3240,9 +3246,20 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
     def covariantDisjoint(tp1: Type, tp2: Type, tparam: TypeParamInfo): Boolean =
       provablyDisjoint(tp1, tp2, pending) && typeparamCorrespondsToField(cls.appliedRef, tparam)
 
-    // In the invariant case, direct type parameter disjointness is enough.
+    // In the invariant case, we have more ways to prove disjointness:
+    // - either the type param corresponds to a field, like in the covariant case, or
+    // - one of the two actual args can never be `Nothing`.
+    // The latter condition, as tested by `cannotBeNothing`, is ad hoc and was
+    // not carefully evaluated to be sound. We have it because we had to
+    // reintroduce the former condition to fix #21295, and alone, that broke a
+    // lot of existing test cases.
+    // Having either one of the two conditions be true is better than not requiring
+    // any, which was the status quo before #21295.
     def invariantDisjoint(tp1: Type, tp2: Type, tparam: TypeParamInfo): Boolean =
-      provablyDisjoint(tp1, tp2, pending)
+      provablyDisjoint(tp1, tp2, pending) && {
+        typeparamCorrespondsToField(cls.appliedRef, tparam)
+          || (cannotBeNothing(tp1) || cannotBeNothing(tp2))
+      }
 
     args1.lazyZip(args2).lazyZip(cls.typeParams).exists {
       (arg1, arg2, tparam) =>
diff --git a/tests/pos/i21295.scala b/tests/pos/i21295.scala
new file mode 100644
index 000000000000..fc2db7c452d9
--- /dev/null
+++ b/tests/pos/i21295.scala
@@ -0,0 +1,8 @@
+sealed trait Foo[A]
+final class Bar extends Foo[Nothing]
+
+object Test:
+  type Extract[T] = T match
+    case Foo[_] => Int
+
+  val x: Extract[Bar] = 1

From 9d2aeacae28f970139651240dda8f78bdd86574a Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 9 Oct 2024 14:59:42 +0100
Subject: [PATCH 114/306] Allow autotupling if fn's param is a type param

---
 .../src/dotty/tools/dotc/typer/Applications.scala | 14 +++++++++++++-
 tests/pos/i21682.1.scala                          | 15 +++++++++++++++
 tests/pos/i21682.2.scala                          |  7 +++++++
 tests/pos/i21682.3.scala                          |  4 ++++
 4 files changed, 39 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i21682.1.scala
 create mode 100644 tests/pos/i21682.2.scala
 create mode 100644 tests/pos/i21682.3.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index 17be2acc7378..26199aa8da37 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -2237,7 +2237,19 @@ trait Applications extends Compatibility {
 
         def isCorrectUnaryFunction(alt: TermRef): Boolean =
           val formals = params(alt)
-          formals.length == 1 && ptIsCorrectProduct(formals.head, args)
+          formals.length == 1 && {
+            formals.head match
+              case formal: TypeParamRef =>
+                // While `formal` isn't a tuple type of the correct arity,
+                // it's a type parameter (a method type parameter presumably)
+                // so check its bounds allow for a tuple type of the correct arity.
+                // See i21682 for an example.
+                val tup = defn.tupleType(args.map(v => if v.tpt.isEmpty then WildcardType else typedAheadType(v.tpt).tpe))
+                val TypeBounds(lo, hi) = formal.paramInfo
+                lo <:< tup && tup <:< hi
+              case formal =>
+                ptIsCorrectProduct(formal, args)
+          }
 
         val numArgs = args.length
         if numArgs > 1
diff --git a/tests/pos/i21682.1.scala b/tests/pos/i21682.1.scala
new file mode 100644
index 000000000000..7340edcaeb4d
--- /dev/null
+++ b/tests/pos/i21682.1.scala
@@ -0,0 +1,15 @@
+sealed abstract class Gen[+T1]
+given [T2]: Conversion[T2, Gen[T2]] = ???
+
+trait Show[T3]
+given Show[Boolean] = ???
+given [A1: Show, B1: Show, C1: Show]: Show[(A1, B1, C1)] = ???
+
+object ForAll:
+  def apply[A2: Show, B2](f: A2 => B2): Unit = ???
+  def apply[A3: Show, B3: Show, C3](f: (A3, B3) => C3): Unit = ???
+  def apply[A4: Show, B4](gen: Gen[A4])(f: A4 => B4): Unit = ???
+
+@main def Test =
+  ForAll: (b1: Boolean, b2: Boolean, b3: Boolean) =>
+    ???
diff --git a/tests/pos/i21682.2.scala b/tests/pos/i21682.2.scala
new file mode 100644
index 000000000000..6717d36c78a6
--- /dev/null
+++ b/tests/pos/i21682.2.scala
@@ -0,0 +1,7 @@
+object ForAll:
+  def apply[A1, B](f: A1 => B): Unit = ???
+  def apply[A1, A2, B](f: (A1, A2) => B): Unit = ???
+
+@main def Test =
+  ForAll: (b1: Boolean, b2: Boolean, b3: Boolean) =>
+    ???
diff --git a/tests/pos/i21682.3.scala b/tests/pos/i21682.3.scala
new file mode 100644
index 000000000000..b44b9a7c91fc
--- /dev/null
+++ b/tests/pos/i21682.3.scala
@@ -0,0 +1,4 @@
+class Test:
+  def foo[A1 >: (Nothing, Boolean, Nothing) <: (Any, Boolean, Any), B](f: A1 => B): Unit = ???
+  def test(): Unit =
+    val res4 = this.foo((b1: Boolean, b2: Boolean, b3: Boolean) => ???)

From 83c75dd62a90c6e60f9135b020cd508756c90d6e Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Wed, 6 Nov 2024 13:23:03 +0100
Subject: [PATCH 115/306] Add .msi artifacts to release assets (#21834)

We now include .msi files produced by `build-msi-package` in release
assets including both .msi file and it's sha256

Resolves #21820
---
 .github/workflows/ci.yaml | 80 ++++++++++++++++++++++++++++++---------
 1 file changed, 62 insertions(+), 18 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 5562423720d8..19405db61066 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -737,7 +737,7 @@ jobs:
         - ${{ github.workspace }}/../../cache/sbt:/root/.sbt
         - ${{ github.workspace }}/../../cache/ivy:/root/.ivy2/cache
         - ${{ github.workspace }}/../../cache/general:/root/.cache
-    needs: [test_non_bootstrapped, test, mima, community_build_a, community_build_b, community_build_c, test_sbt, test_java8, build-sdk-package]
+    needs: [test_non_bootstrapped, test, mima, community_build_a, community_build_b, community_build_c, test_sbt, test_java8, build-sdk-package, build-msi-package]
     if: "github.event_name == 'push'
          && startsWith(github.event.ref, 'refs/tags/')"
 
@@ -816,6 +816,18 @@ jobs:
           prepareSDK "-x86_64-apple-darwin"  "dist-mac-x86_64"    "./dist/mac-x86_64/"
           prepareSDK "-x86_64-pc-win32"      "dist-win-x86_64"    "./dist/win-x86_64/"
 
+      - name: Download MSI package
+        uses: actions/download-artifact@v4
+        with:
+          name: scala.msi
+          path: .
+      - name: Prepare MSI package
+        shell: bash
+        run: | 
+          msiInstaller="scala3-${{ env.RELEASE_TAG }}.msi"
+          mv scala.msi "${msiInstaller}"
+          sha256sum "${msiInstaller}" > "${msiInstaller}.sha256"
+
       # Create the GitHub release
       - name: Create GitHub Release
         id: create_gh_release
@@ -829,10 +841,10 @@ jobs:
           draft: true
           prerelease: ${{ contains(env.RELEASE_TAG, '-') }}
 
-      # The following steps are generated using template:
-      # def template(distribution: String, suffix: String) =
-      #   def upload(kind: String, path: String, contentType: String) =
-      #     s"""- name: Upload $kind to GitHub Release ($distribution)
+      # The following upload steps are generated using template:
+      # val baseFileName = "scala3-${{ env.RELEASE_TAG }}"
+      # def upload(kind: String, path: String, contentType: String, distribution: String) =
+      #   s"""- name: Upload $kind to GitHub Release ($distribution)
       #         uses: actions/upload-release-asset@v1
       #         env:
       #           GITHUB_TOKEN: $${{ secrets.GITHUB_TOKEN }}
@@ -841,24 +853,33 @@ jobs:
       #           asset_path: ./${path}
       #           asset_name: ${path}
       #           asset_content_type: ${contentType}"""
-      #   val filename = s"scala3-$${{ env.RELEASE_TAG }}${suffix}"
+      # def uploadSDK(distribution: String, suffix: String) =
+      #   val filename = s"${baseFileName}${suffix}"
       #   s"""
       #       # $distribution
-      #       ${upload("zip archive", s"$filename.zip", "application/zip")}
-      #       ${upload("zip archive SHA", s"$filename.zip.sha256", "text/plain")}
-      #       ${upload("tar.gz archive", s"$filename.tar.gz", "application/gzip")}
-      #       ${upload("tar.gz archive SHA", s"$filename.tar.gz.sha256", "text/plain")}
+      #       ${upload("zip archive", s"$filename.zip", "application/zip", distribution)}
+      #       ${upload("zip archive SHA", s"$filename.zip.sha256", "text/plain", distribution)}
+      #       ${upload("tar.gz archive", s"$filename.tar.gz", "application/gzip", distribution)}
+      #       ${upload("tar.gz archive SHA", s"$filename.tar.gz.sha256", "text/plain", distribution)}
+      # """
+      # def uploadMSI() = 
+      #     val distribution = "Windows x86_64 MSI"
+      #     s"""
+      #       # $distribution
+      #       ${upload(".msi file", s"${baseFileName}.msi", "application/x-msi", distribution)}
+      #       ${upload(".msi file SHA", s"${baseFileName}.msi.sha256", "text/plain", distribution)}
       # """
-
       # @main def gen =
       #   Seq(
-      #     template("Universal", ""),
-      #     template("Linux x86-64", "-x86_64-pc-linux"),
-      #     template("Linux aarch64", "-aarch64-pc-linux"),
-      #     template("Mac x86-64", "-x86_64-apple-darwin"),
-      #     template("Mac aarch64", "-aarch64-apple-darwin"),
-      #     template("Windows x86_64", "-x86_64-pc-win32")
+      #     uploadSDK("Universal", ""),
+      #     uploadSDK("Linux x86-64", "-x86_64-pc-linux"),
+      #     uploadSDK("Linux aarch64", "-aarch64-pc-linux"),
+      #     uploadSDK("Mac x86-64", "-x86_64-apple-darwin"),
+      #     uploadSDK("Mac aarch64", "-aarch64-apple-darwin"),
+      #     uploadSDK("Windows x86_64", "-x86_64-pc-win32"),
+      #     uploadMSI()
       #   ).foreach(println)
+
       # Universal
       - name: Upload zip archive to GitHub Release (Universal)
         uses: actions/upload-release-asset@v1
@@ -1092,6 +1113,27 @@ jobs:
           asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-pc-win32.tar.gz.sha256
           asset_content_type: text/plain
 
+
+      # Windows x86_64 MSI
+      - name: Upload .msi file to GitHub Release (Windows x86_64 MSI)
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}.msi
+          asset_name: scala3-${{ env.RELEASE_TAG }}.msi
+          asset_content_type: application/x-msi
+      - name: Upload .msi file SHA to GitHub Release (Windows x86_64 MSI)
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}.msi.sha256
+          asset_name: scala3-${{ env.RELEASE_TAG }}.msi.sha256
+          asset_content_type: text/plain
+
       - name: Publish Release
         run: ./project/scripts/sbtPublish ";project scala3-bootstrapped ;publishSigned ;sonatypeBundleUpload"
 
@@ -1118,7 +1160,9 @@ jobs:
 
   build-msi-package:
     uses: ./.github/workflows/build-msi.yml
-    if  : github.event_name == 'pull_request' && contains(github.event.pull_request.body, '[test_msi]')
+    if  :
+      (github.event_name == 'pull_request' && contains(github.event.pull_request.body, '[test_msi]')) ||
+      (github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags/'))
 
   test-msi-package:
     uses: ./.github/workflows/test-msi.yml

From 74920d38d0e9943a8c7f1550d17d2eec97e03d6d Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Wed, 6 Nov 2024 13:33:23 +0100
Subject: [PATCH 116/306] Don't typeAhead erroneous parsing trees related to
 export statements

---
 .../src/dotty/tools/dotc/typer/Namer.scala    |  2 +-
 tests/neg/i20511-1.check                      | 32 +++++++++++++++++++
 tests/neg/i20511-1.scala                      |  2 +-
 tests/neg/i20511.check                        | 12 +++++++
 4 files changed, 46 insertions(+), 2 deletions(-)
 create mode 100644 tests/neg/i20511-1.check
 create mode 100644 tests/neg/i20511.check

diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 83964417a6f1..5b8cac9b1684 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -1131,7 +1131,7 @@ class Namer { typer: Typer =>
     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
+      if expr.isEmpty || selectors.exists(_.imported.name == nme.ERROR) then
         report.error(em"Export selector must have prefix and `.`", exp.srcPos)
         return Nil
 
diff --git a/tests/neg/i20511-1.check b/tests/neg/i20511-1.check
new file mode 100644
index 000000000000..3f64940bb4fe
--- /dev/null
+++ b/tests/neg/i20511-1.check
@@ -0,0 +1,32 @@
+-- [E083] Type Error: tests/neg/i20511-1.scala:7:7 ---------------------------------------------------------------------
+7 |export toppingPrice.apply, crustPrice.apply, crustPrice.unlift // error // error // error // error // error
+  |       ^^^^^^^^^^^^
+  |       Int => Double is not a valid export prefix, since it is not an immutable path
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E083] Type Error: tests/neg/i20511-1.scala:7:27 --------------------------------------------------------------------
+7 |export toppingPrice.apply, crustPrice.apply, crustPrice.unlift // error // error // error // error // error
+  |                           ^^^^^^^^^^
+  |                           Any is not a valid export prefix, since it is not an immutable path
+  |
+  | longer explanation available when compiling with `-explain`
+-- Error: tests/neg/i20511-1.scala:7:38 --------------------------------------------------------------------------------
+7 |export toppingPrice.apply, crustPrice.apply, crustPrice.unlift // error // error // error // error // error
+  |                                      ^^^^^
+  |                                      no eligible member apply at {
+  |                                        def $anonfun(crustType: Double): Double = pakiet.crustPrice(crustType)
+  |                                        closure(pakiet.$anonfun:Any)
+  |                                      }
+-- [E083] Type Error: tests/neg/i20511-1.scala:7:45 --------------------------------------------------------------------
+7 |export toppingPrice.apply, crustPrice.apply, crustPrice.unlift // error // error // error // error // error
+  |                                             ^^^^^^^^^^
+  |                                             Any is not a valid export prefix, since it is not an immutable path
+  |
+  | longer explanation available when compiling with `-explain`
+-- Error: tests/neg/i20511-1.scala:7:56 --------------------------------------------------------------------------------
+7 |export toppingPrice.apply, crustPrice.apply, crustPrice.unlift // error // error // error // error // error
+  |                                                        ^^^^^^
+  |                                          no eligible member unlift at {
+  |                                            def $anonfun(crustType: Double): Double = pakiet.crustPrice(crustType)
+  |                                            closure(pakiet.$anonfun:Any)
+  |                                          }
diff --git a/tests/neg/i20511-1.scala b/tests/neg/i20511-1.scala
index 03bd475ffafd..882520b55c07 100644
--- a/tests/neg/i20511-1.scala
+++ b/tests/neg/i20511-1.scala
@@ -4,4 +4,4 @@ def toppingPrice(size: Int): Double = ???
 
 def crustPrice(crustType: Double): Double = ???
 
-export toppingPrice.apply, crustPrice.unlift // error // error // error
+export toppingPrice.apply, crustPrice.apply, crustPrice.unlift // error // error // error // error // error
diff --git a/tests/neg/i20511.check b/tests/neg/i20511.check
new file mode 100644
index 000000000000..27c8126d43ab
--- /dev/null
+++ b/tests/neg/i20511.check
@@ -0,0 +1,12 @@
+-- [E040] Syntax Error: tests/neg/i20511.scala:7:19 --------------------------------------------------------------------
+7 |export toppingPrice, crustPrice // error // error
+  |                   ^
+  |                   '.' expected, but ',' found
+-- [E040] Syntax Error: tests/neg/i20511.scala:8:0 ---------------------------------------------------------------------
+8 |val i = 1 // error
+  |^^^
+  |'.' expected, but 'end of statement' found
+-- Error: tests/neg/i20511.scala:7:21 ----------------------------------------------------------------------------------
+7 |export toppingPrice, crustPrice // error // error
+  |                     ^^^^^^^^^^
+  |                     Export selector must have prefix and `.`

From 0a04b68eeda258e7fb3cec8551c19d49c4292679 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 27 Aug 2024 22:35:19 +0100
Subject: [PATCH 117/306] Remove tvars introduced while testing
 normalizedCompatible

---
 .../dotty/tools/dotc/core/TyperState.scala    |  5 ++--
 .../src/dotty/tools/dotc/core/Types.scala     |  3 ++-
 .../tools/dotc/printing/Formatting.scala      |  2 +-
 .../tools/dotc/printing/PlainPrinter.scala    |  2 +-
 .../dotty/tools/dotc/typer/ProtoTypes.scala   |  8 +++++++
 .../dotty/tools/dotc/typer/TypeAssigner.scala | 17 ++++++-------
 .../src/dotty/tools/dotc/typer/Typer.scala    | 24 ++++++++++++++++++-
 tests/pos/interleaving-overload.cleanup.scala |  9 +++++++
 tests/pos/zipped.min.scala                    | 15 ++++++++++++
 9 files changed, 71 insertions(+), 14 deletions(-)
 create mode 100644 tests/pos/interleaving-overload.cleanup.scala
 create mode 100644 tests/pos/zipped.min.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TyperState.scala b/compiler/src/dotty/tools/dotc/core/TyperState.scala
index 160d7749de61..d4345916ba77 100644
--- a/compiler/src/dotty/tools/dotc/core/TyperState.scala
+++ b/compiler/src/dotty/tools/dotc/core/TyperState.scala
@@ -139,14 +139,15 @@ class TyperState() {
   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
+  /** Commit `this` typer state by copying information into the current typer state,
+   *  where "current" means contextual, so meaning `ctx.typerState`.
    *  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:
+   *  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)
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index d8a4453325f2..ca9d73df03aa 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -4124,6 +4124,7 @@ object Types extends TypeUtils {
     protected def prefixString: String = companion.prefixString
   }
 
+  // Actually.. not cached.  MethodOrPoly are `UncachedGroundType`s.
   final class CachedMethodType(paramNames: List[TermName])(paramInfosExp: MethodType => List[Type], resultTypeExp: MethodType => Type, val companion: MethodTypeCompanion)
     extends MethodType(paramNames)(paramInfosExp, resultTypeExp)
 
@@ -4884,7 +4885,7 @@ object Types extends TypeUtils {
     def origin: TypeParamRef = currentOrigin
 
     /** Set origin to new parameter. Called if we merge two conflicting constraints.
-     *  See OrderingConstraint#merge, OrderingConstraint#rename
+     *  See OrderingConstraint#merge
      */
     def setOrigin(p: TypeParamRef) = currentOrigin = p
 
diff --git a/compiler/src/dotty/tools/dotc/printing/Formatting.scala b/compiler/src/dotty/tools/dotc/printing/Formatting.scala
index 5870731dadfa..ccd7b4e4e282 100644
--- a/compiler/src/dotty/tools/dotc/printing/Formatting.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Formatting.scala
@@ -184,7 +184,7 @@ object Formatting {
     * 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
+    * Please note that if used in combination with `disambiguateTypes` the
     * correct `Context` for printing should also be passed when calling the
     * method.
     *
diff --git a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
index b5ed3bdb4fa7..cac82eb0c4bd 100644
--- a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -253,7 +253,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
           toTextCapturing(parent, refsText, "") ~ Str("R").provided(printDebug)
         else toText(parent)
       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
+        "<error>" // do not print previously reported error message because they may try to print this error type again recursively
       case tp: ErrorType =>
         s"<error ${tp.msg.message}>"
       case tp: WildcardType =>
diff --git a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
index 53e0b456ed9a..9a94c50deb7f 100644
--- a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -71,6 +71,14 @@ object ProtoTypes {
                    |constraint was: ${ctx.typerState.constraint}
                    |constraint now: ${newctx.typerState.constraint}""")
             if result && (ctx.typerState.constraint ne newctx.typerState.constraint) then
+              // Remove all type lambdas and tvars introduced by testCompat
+              for tvar <- newctx.typerState.ownedVars do
+                val tl = tvar.origin.binder
+                newctx.typerState.ownedVars -= tvar
+                if newctx.typerState.constraint.contains(tl) then
+                  newctx.typerState.constraint = newctx.typerState.constraint.remove(tl)(using newctx)
+
+              // commit any remaining changes in typer state
               newctx.typerState.commit()
             result
           case _ => testCompat
diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
index fd16f0de5f3a..f74ab65b6e4a 100644
--- a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -360,20 +360,21 @@ trait TypeAssigner {
                 resultType1)
             }
           }
+          else if !args.hasSameLengthAs(paramNames) then
+            wrongNumberOfTypeArgs(fn.tpe, pt.typeParams, args, tree.srcPos)
           else {
             // Make sure arguments don't contain the type `pt` itself.
-            // make a copy of the argument if that's the case.
+            // Make a copy of `pt` 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)
+            val needsFresh = new ExistsAccumulator(_ eq pt, StopAt.None, forceLazy = false)
+            val argTypes = args.tpes
+            val pt1 = if argTypes.exists(needsFresh(false, _)) then
+              pt.newLikeThis(pt.paramNames, pt.paramInfos, pt.resType)
+            else pt
+            pt1.instantiate(argTypes)
           }
         }
       case err: ErrorType =>
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 817e7baf1c8c..e8b5813c83bd 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -4754,7 +4754,29 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
               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.map(_.wrapInTypeTree(tree))
+              if typeArgs.isEmpty then
+                val poly1 = tree match
+                  case Select(qual, nme.apply) => qual.tpe.widen match
+                    case defn.PolyFunctionOf(_) =>
+                      // Given a poly function, like the one in i6682a:
+                      //    val v = [T] => (y:T) => (x:y.type) => 3
+                      // It's possible to apply `v(v)` which extends to:
+                      //    v.apply[?T](v)
+                      // Requiring the circular constraint `v <: ?T`,
+                      // (because type parameter T occurs in v's type).
+                      // So we create a fresh copy of the outer
+                      // poly method type, so we now extend to:
+                      //    v.apply[?T'](v)
+                      // Where `?T'` is a type var for a T' type parameter,
+                      // leading to the non-circular `v <: ?T'` constraint.
+                      //
+                      // This also happens in `assignType(tree: untpd.TypeApply, ..)`
+                      // to avoid any type arguments, containing the type lambda,
+                      // being applied to the very same type lambda.
+                      poly.newLikeThis(poly.paramNames, poly.paramInfos, poly.resType)
+                    case _ => poly
+                  case _ => poly
+                typeArgs = constrained(poly1, tree)._2.map(_.wrapInTypeTree(tree))
               convertNewGenericArray(readapt(tree.appliedToTypeTrees(typeArgs)))
         case wtp =>
           val isStructuralCall = wtp.isValueType && isStructuralTermSelectOrApply(tree)
diff --git a/tests/pos/interleaving-overload.cleanup.scala b/tests/pos/interleaving-overload.cleanup.scala
new file mode 100644
index 000000000000..6eb2f16de15d
--- /dev/null
+++ b/tests/pos/interleaving-overload.cleanup.scala
@@ -0,0 +1,9 @@
+// A minimisation of interleaving-overload
+// Used while developing the tvar/tl clearnup in normalizedCompatible
+class B[U]
+class Test():
+  def fn[T]: [U] => Int => B[U] = [U] => (x: Int) => new B[U]()
+  def test(): Unit =
+    fn(1)
+    fn(2)
+    ()
diff --git a/tests/pos/zipped.min.scala b/tests/pos/zipped.min.scala
new file mode 100644
index 000000000000..5d15b3fae240
--- /dev/null
+++ b/tests/pos/zipped.min.scala
@@ -0,0 +1,15 @@
+// Justifies the need for TypeApply in tryInsertImplicitOnQualifier
+// after failing ys.map[?B, C] using Zipped2's map
+// we want to try ys.map[?B] using Coll's map, after toColl
+final class Coll[+A]:
+  def map[B](f: A => B): Coll[B] = new Coll[B]
+  def lazyZip[B](that: Coll[B]): Zipped2[A, B] = new Zipped2[A, B](this, that)
+final class Zipped2[+X, +Y](xs: Coll[X], ys: Coll[Y]):
+  def map[B, C](f: (X, Y) => B): Coll[C] = new Coll[C]
+object Zipped2:
+  import scala.language.implicitConversions
+  implicit def toColl[X, Y](zipped2: Zipped2[X, Y]): Coll[(X, Y)] = new Coll[(X, Y)]
+class Test:
+  def test(xs: Coll[Int]): Unit =
+    val ys = xs.lazyZip(xs)
+    ys.map((x: (Int, Int)) => x._1 + x._2)

From f9145d73a000cc8391cf2fe3e2b9fe1c0b4683a7 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 6 Nov 2024 15:32:10 +0000
Subject: [PATCH 118/306] Move makePackageObjPrefixExplicit to TypeUtils

---
 .../dotty/tools/dotc/core/TypeErasure.scala   |  1 -
 .../src/dotty/tools/dotc/core/TypeOps.scala   | 30 -----------------
 .../src/dotty/tools/dotc/core/TypeUtils.scala | 32 ++++++++++++++++++-
 .../tools/dotc/core/tasty/TreeUnpickler.scala |  2 +-
 .../dotty/tools/dotc/typer/TypeAssigner.scala |  2 +-
 5 files changed, 33 insertions(+), 34 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
index 9491bdab9de8..33a1b6ae789e 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
@@ -5,7 +5,6 @@ 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.*
diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
index 79eac7bde38d..a6981c7c6e95 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -560,36 +560,6 @@ object TypeOps:
     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
diff --git a/compiler/src/dotty/tools/dotc/core/TypeUtils.scala b/compiler/src/dotty/tools/dotc/core/TypeUtils.scala
index 485272fe71c5..f343d7227bf8 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeUtils.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeUtils.scala
@@ -3,7 +3,7 @@ package dotc
 package core
 
 import TypeErasure.ErasedValueType
-import Types.*, Contexts.*, Symbols.*, Flags.*, Decorators.*
+import Types.*, Contexts.*, Symbols.*, Flags.*, Decorators.*, SymDenotations.*
 import Names.{Name, TermName}
 import Constants.Constant
 
@@ -186,6 +186,36 @@ class TypeUtils:
       case self: Types.ThisType => self.cls == cls
       case _ => false
 
+    /** If `self` 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(using Context): Type =
+      def tryInsert(tpe: NamedType, 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 then tpe.derivedSelect(pobj.termRef)
+          else tpe
+        case _ =>
+          tpe
+      self match
+      case tpe: NamedType =>
+        if tpe.symbol.isRoot then
+          tpe
+        else
+          tpe.prefix match
+            case pre: ThisType if pre.cls.is(Package) => tryInsert(tpe, pre.cls)
+            case pre: TermRef if pre.symbol.is(Package) => tryInsert(tpe, pre.symbol.moduleClass)
+            case _ => tpe
+      case tpe => tpe
+
     /** Strip all outer refinements off this type */
     def stripRefinement: Type = self match
       case self: RefinedOrRecType => self.parent.stripRefinement
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index e62db9af520a..44b305db43c8 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1272,7 +1272,7 @@ class TreeUnpickler(reader: TastyReader,
         val tpe0 = name match
           case name: TypeName => TypeRef(qualType, name, denot)
           case name: TermName => TermRef(qualType, name, denot)
-        val tpe = TypeOps.makePackageObjPrefixExplicit(tpe0)
+        val tpe = tpe0.makePackageObjPrefixExplicit
         ConstFold.Select(untpd.Select(qual, name).withType(tpe))
 
       def completeSelect(name: Name, sig: Signature, target: Name): Select =
diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
index fd16f0de5f3a..bf5a75ff508a 100644
--- a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -85,7 +85,7 @@ trait TypeAssigner {
       defn.FromJavaObjectType
     else tpe match
       case tpe: NamedType =>
-        val tpe1 = TypeOps.makePackageObjPrefixExplicit(tpe)
+        val tpe1 = tpe.makePackageObjPrefixExplicit
         if tpe1 ne tpe then
           accessibleType(tpe1, superAccess)
         else

From 63849a01711f7ae2c837b2acc5093d522dbe4b10 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Wed, 6 Nov 2024 18:09:07 +0100
Subject: [PATCH 119/306] Set developedVersion to 3.6.3. (#21892)

It was decided that 3.6.2 would be the first (official) stable release
of the 3.6 series.

3.6.2 would be based on 3.6.0/3.6.1 release but including backported
fixes
3.6.3 is treated as 1st real patch release, it's still being developed
in current development cycle.
---
 project/Build.scala | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/project/Build.scala b/project/Build.scala
index 03850a5c0f0d..49d990b639c4 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -102,15 +102,15 @@ object Build {
   /** Version of the Scala compiler targeted in the current release cycle
    *  Contains a version without RC/SNAPSHOT/NIGHTLY specific suffixes
    *  Should be updated ONLY after release or cutoff for previous release cycle.
-   *  
-   *  Should only be referred from `dottyVersion` or settings/tasks requiring simplified version string, 
+   *
+   *  Should only be referred from `dottyVersion` or settings/tasks requiring simplified version string,
    *  eg. `compatMode` or Windows native distribution version.
    */
-  val developedVersion = "3.6.2"
+  val developedVersion = "3.6.3"
 
-  /** The version of the compiler including the RC prefix. 
+  /** The version of the compiler including the RC prefix.
    *  Defined as common base before calculating environment specific suffixes in `dottyVersion`
-   * 
+   *
    *  By default, during development cycle defined as `${developedVersion}-RC1`;
    *  During release candidate cycle incremented by the release officer before publishing a subsequent RC version;
    *  During final, stable release is set exactly to `developedVersion`.

From cecd05356beecd232053d4c593af54bcc12cad0e Mon Sep 17 00:00:00 2001
From: Hamza Remmal <hamza@remmal.net>
Date: Wed, 6 Nov 2024 18:16:33 +0100
Subject: [PATCH 120/306] Revert "Drop inaccessible subclasses from
 refineUsingParent"

---
 .../src/dotty/tools/dotc/core/Decorators.scala     |  2 +-
 compiler/src/dotty/tools/dotc/core/TypeOps.scala   |  6 +-----
 tests/pos/i21790.scala                             | 14 --------------
 3 files changed, 2 insertions(+), 20 deletions(-)
 delete mode 100644 tests/pos/i21790.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Decorators.scala b/compiler/src/dotty/tools/dotc/core/Decorators.scala
index 96a2d45db80d..29d4b3fa4052 100644
--- a/compiler/src/dotty/tools/dotc/core/Decorators.scala
+++ b/compiler/src/dotty/tools/dotc/core/Decorators.scala
@@ -292,7 +292,7 @@ object Decorators {
       case _ => String.valueOf(x).nn
 
     /** Returns the simple class name of `x`. */
-    def className: String = if x == null then "<null>" else x.getClass.getSimpleName.nn
+    def className: String = x.getClass.getSimpleName.nn
 
   extension [T](x: T)
     def assertingErrorsReported(using Context): T = {
diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
index 79eac7bde38d..2403a6e22bc6 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -930,11 +930,7 @@ object TypeOps:
       for tp <- mixins.reverseIterator do
         protoTp1 <:< tp
       maximizeType(protoTp1, NoSpan)
-      val inst = wildApprox(protoTp1)
-      if !inst.classSymbol.exists then
-        // E.g. i21790, can't instantiate S#CA as a subtype of O.A, because O.CA isn't accessible
-        NoType
-      else inst
+      wildApprox(protoTp1)
     }
 
     if (protoTp1 <:< tp2) instantiate()
diff --git a/tests/pos/i21790.scala b/tests/pos/i21790.scala
deleted file mode 100644
index 0cc7db935ac7..000000000000
--- a/tests/pos/i21790.scala
+++ /dev/null
@@ -1,14 +0,0 @@
-package p
-
-trait S:
-  sealed trait A
-  private class CA() extends A
-
-object O extends S
-
-trait T
-
-class Test:
-  def f(e: T) = e match
-    case _: O.A =>
-    case _      =>

From 144fecbef774ea15f5ed950017906035e90c5097 Mon Sep 17 00:00:00 2001
From: Seth Tisue <seth@tisue.net>
Date: Wed, 10 Apr 2024 10:01:26 -0700
Subject: [PATCH 121/306] sbt 1.10.5 (was 1.9.9)

and compiler-interface to 1.10.4, there is no 1.10.5 for that

fastparse was on Scala 2.13.0, needed updating to 2.13.15
---
 .github/Dockerfile                                              | 2 +-
 community-build/community-projects/fastparse                    | 2 +-
 community-build/src/scala/dotty/communitybuild/projects.scala   | 2 +-
 project/Dependencies.scala                                      | 2 +-
 project/build.properties                                        | 2 +-
 .../sourcepath-with-inline-api-hash/project/build.properties    | 2 +-
 .../sourcepath-with-inline/project/build.properties             | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/Dockerfile b/.github/Dockerfile
index 59d46fd169d9..3ba5466c30b8 100644
--- a/.github/Dockerfile
+++ b/.github/Dockerfile
@@ -22,5 +22,5 @@ RUN apt-get update && \
 # Install sbt
 ENV SBT_HOME /usr/local/sbt
 ENV PATH ${SBT_HOME}/bin:${PATH}
-ENV SBT_VERSION 1.9.0
+ENV SBT_VERSION 1.10.5
 RUN curl -sL "https://github.com/sbt/sbt/releases/download/v$SBT_VERSION/sbt-$SBT_VERSION.tgz" | gunzip | tar -x -C /usr/local
\ No newline at end of file
diff --git a/community-build/community-projects/fastparse b/community-build/community-projects/fastparse
index 8b93438064ae..4c416b222ad3 160000
--- a/community-build/community-projects/fastparse
+++ b/community-build/community-projects/fastparse
@@ -1 +1 @@
-Subproject commit 8b93438064aecc7b94f4647af47c0fa237bf89a9
+Subproject commit 4c416b222ad3dcf0bc71656e22407fa49aec193a
diff --git a/community-build/src/scala/dotty/communitybuild/projects.scala b/community-build/src/scala/dotty/communitybuild/projects.scala
index 31c1bb95743c..2575bb2037c0 100644
--- a/community-build/src/scala/dotty/communitybuild/projects.scala
+++ b/community-build/src/scala/dotty/communitybuild/projects.scala
@@ -128,7 +128,7 @@ final case class SbtCommunityProject(
       case Some(ivyHome) => List(s"-Dsbt.ivy.home=$ivyHome")
       case _ => Nil
     extraSbtArgs ++ sbtProps ++ List(
-      "-sbt-version", "1.9.7",
+      "-sbt-version", "1.10.5",
       "-Dsbt.supershell=false",
       s"-Ddotty.communitybuild.dir=$communitybuildDir",
       s"--addPluginSbtFile=$sbtPluginFilePath"
diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index 88a97721ee3c..427b53e45221 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -28,5 +28,5 @@ object Dependencies {
     "com.vladsch.flexmark" % "flexmark-ext-yaml-front-matter" % flexmarkVersion,
   )
 
-  val compilerInterface = "org.scala-sbt" % "compiler-interface" % "1.9.6"
+  val compilerInterface = "org.scala-sbt" % "compiler-interface" % "1.10.4"
 }
diff --git a/project/build.properties b/project/build.properties
index 04267b14af69..db1723b08622 100644
--- a/project/build.properties
+++ b/project/build.properties
@@ -1 +1 @@
-sbt.version=1.9.9
+sbt.version=1.10.5
diff --git a/tests/cmdTest-sbt-tests/sourcepath-with-inline-api-hash/project/build.properties b/tests/cmdTest-sbt-tests/sourcepath-with-inline-api-hash/project/build.properties
index e8a1e246e8ad..db1723b08622 100644
--- a/tests/cmdTest-sbt-tests/sourcepath-with-inline-api-hash/project/build.properties
+++ b/tests/cmdTest-sbt-tests/sourcepath-with-inline-api-hash/project/build.properties
@@ -1 +1 @@
-sbt.version=1.9.7
+sbt.version=1.10.5
diff --git a/tests/cmdTest-sbt-tests/sourcepath-with-inline/project/build.properties b/tests/cmdTest-sbt-tests/sourcepath-with-inline/project/build.properties
index e8a1e246e8ad..db1723b08622 100644
--- a/tests/cmdTest-sbt-tests/sourcepath-with-inline/project/build.properties
+++ b/tests/cmdTest-sbt-tests/sourcepath-with-inline/project/build.properties
@@ -1 +1 @@
-sbt.version=1.9.7
+sbt.version=1.10.5

From 74349e85a7450e6914b1bbc2d803edf341d23395 Mon Sep 17 00:00:00 2001
From: Eugene Flesselle <eugene@flesselle.net>
Date: Mon, 29 Apr 2024 11:32:05 +0200
Subject: [PATCH 122/306] Add an infix shorthand for `Tuple.Append`

Addressing #19175
---
 library/src/scala/Tuple.scala | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/library/src/scala/Tuple.scala b/library/src/scala/Tuple.scala
index 8074fe3664e5..343194d06488 100644
--- a/library/src/scala/Tuple.scala
+++ b/library/src/scala/Tuple.scala
@@ -22,8 +22,8 @@ sealed trait Tuple extends Product {
     runtime.Tuples.toIArray(this)
 
   /** Return a copy of `this` tuple with an element appended */
-  inline def :* [This >: this.type <: Tuple, L] (x: L): Append[This, L] =
-    runtime.Tuples.append(x, this).asInstanceOf[Append[This, L]]
+  inline def :* [This >: this.type <: Tuple, L] (x: L): This :* L =
+    runtime.Tuples.append(x, this).asInstanceOf[This :* L]
 
   /** Return a new tuple by prepending the element to `this` tuple.
    *  This operation is O(this.size)
@@ -94,6 +94,9 @@ object Tuple {
     case x *: xs => x *: Append[xs, Y]
   }
 
+  /** An infix shorthand for `Append[X, Y]` */
+  infix type :*[X <: Tuple, Y] = Append[X, Y]
+
   /** Type of the head of a tuple */
   type Head[X <: Tuple] = X match {
     case x *: _ => x

From 4e47edfa789ca8f4c2175ebfb95dc43f09e29aa3 Mon Sep 17 00:00:00 2001
From: Eugene Flesselle <eugene@flesselle.net>
Date: Mon, 29 Jul 2024 10:51:38 +0200
Subject: [PATCH 123/306] Add an infix shorthand for `Tuple.Concat`

Addressing #19175
---
 library/src/scala/Tuple.scala | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/library/src/scala/Tuple.scala b/library/src/scala/Tuple.scala
index 343194d06488..bf05b617a51d 100644
--- a/library/src/scala/Tuple.scala
+++ b/library/src/scala/Tuple.scala
@@ -34,8 +34,8 @@ sealed trait Tuple extends Product {
   /** Return a new tuple by concatenating `this` tuple with `that` tuple.
    *  This operation is O(this.size + that.size)
    */
-  inline def ++ [This >: this.type <: Tuple](that: Tuple): Concat[This, that.type] =
-    runtime.Tuples.concat(this, that).asInstanceOf[Concat[This, that.type]]
+  inline def ++ [This >: this.type <: Tuple](that: Tuple): This ++ that.type =
+    runtime.Tuples.concat(this, that).asInstanceOf[This ++ that.type]
 
   /** Return the size (or arity) of the tuple */
   inline def size[This >: this.type <: Tuple]: Size[This] =
@@ -126,6 +126,9 @@ object Tuple {
     case x1 *: xs1 => x1 *: Concat[xs1, Y]
   }
 
+  /** An infix shorthand for `Concat[X, Y]` */
+  infix type ++[X <: Tuple, +Y <: Tuple] = Concat[X, Y]
+
   /** Type of the element at position N in the tuple X */
   type Elem[X <: Tuple, N <: Int] = X match {
     case x *: xs =>

From 995d63b140f1078a7c853d92d8fce2138c474c1e Mon Sep 17 00:00:00 2001
From: Eugene Flesselle <eugene@flesselle.net>
Date: Tue, 30 Jul 2024 14:27:50 +0200
Subject: [PATCH 124/306] Combine cases of `Tuple.Zip` disjoint from `(h1 *:
 t1, h2 *: t2)`

If we reach the second case of `Zip[T1 <: Tuple, T2 <: Tuple]`,
then we know `(T1, T2)` is disjoint from `(NonEmptyTuple, NonEmptyTuple)`,
from which we can conclude at least one of the two is an `EmptyTuple`.

Addressing #19175
---
 library/src/scala/Tuple.scala | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/library/src/scala/Tuple.scala b/library/src/scala/Tuple.scala
index 8074fe3664e5..8291e17a5cfc 100644
--- a/library/src/scala/Tuple.scala
+++ b/library/src/scala/Tuple.scala
@@ -175,15 +175,12 @@ object Tuple {
   }
 
   /** Given two tuples, `A1 *: ... *: An * At` and `B1 *: ... *: Bn *: Bt`
-   *  where at least one of `At` or `Bt` is `EmptyTuple` or `Tuple`,
-   *  returns the tuple type `(A1, B1) *: ... *: (An, Bn) *: Ct`
-   *  where `Ct` is `EmptyTuple` if `At` or `Bt` is `EmptyTuple`, otherwise `Ct` is `Tuple`.
+   *  where at least one of `At` or `Bt` is `EmptyTuple`,
+   *  returns the tuple type `(A1, B1) *: ... *: (An, Bn) *: EmptyTuple`.
    */
   type Zip[T1 <: Tuple, T2 <: Tuple] <: Tuple = (T1, T2) match {
     case (h1 *: t1, h2 *: t2) => (h1, h2) *: Zip[t1, t2]
-    case (EmptyTuple, _) => EmptyTuple
-    case (_, EmptyTuple) => EmptyTuple
-    case _ => Tuple
+    case _ => EmptyTuple
   }
 
   /** Converts a tuple `(F[T1], ..., F[Tn])` to `(T1,  ... Tn)` */

From caac72a3c8167a047f5c4180890856108b59bfd4 Mon Sep 17 00:00:00 2001
From: Jan Chyb <jan.chyb.99@gmail.com>
Date: Mon, 30 Sep 2024 17:20:43 +0200
Subject: [PATCH 125/306] Do not warn about expected missing positions in
 quotes reflect.Symbols.pos

---
 .../src/scala/quoted/runtime/impl/QuotesImpl.scala     |  3 ++-
 tests/pos-macros/i21672/Macro_1.scala                  | 10 ++++++++++
 tests/pos-macros/i21672/Test_2.scala                   |  3 +++
 3 files changed, 15 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos-macros/i21672/Macro_1.scala
 create mode 100644 tests/pos-macros/i21672/Test_2.scala

diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index ef2eacf42225..22be293c3562 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -2698,9 +2698,10 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           if self.exists then
             val symPos = self.sourcePos
             if symPos.exists then Some(symPos)
-            else
+            else if self.source.exists then
               if xCheckMacro then report.warning(s"Missing symbol position (defaulting to position 0): $self\nThis is a compiler bug. Please report it.")
               Some(self.source.atSpan(dotc.util.Spans.Span(0)))
+            else None
           else None
 
         def docstring: Option[String] =
diff --git a/tests/pos-macros/i21672/Macro_1.scala b/tests/pos-macros/i21672/Macro_1.scala
new file mode 100644
index 000000000000..2e17631d6cf4
--- /dev/null
+++ b/tests/pos-macros/i21672/Macro_1.scala
@@ -0,0 +1,10 @@
+object Repro {
+  inline def apply(): Unit = ${ applyImpl }
+
+  import scala.quoted.*
+  def applyImpl(using q: Quotes): Expr[Unit] = {
+   import q.reflect.*
+   report.info(TypeRepr.of[Some[String]].typeSymbol.pos.toString)
+   '{ () }
+  }
+}
diff --git a/tests/pos-macros/i21672/Test_2.scala b/tests/pos-macros/i21672/Test_2.scala
new file mode 100644
index 000000000000..b164962100af
--- /dev/null
+++ b/tests/pos-macros/i21672/Test_2.scala
@@ -0,0 +1,3 @@
+//> using options -Xfatal-warnings
+object Test:
+  Repro()

From d8ba366eecc3563b5df8fbb0c8ee5131d3f3479b Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Thu, 7 Nov 2024 19:54:17 +0100
Subject: [PATCH 126/306] Ensure ChromeTraceTest event timestamps are emitted
 in correct invervals

---
 .../tools/dotc/profile/ChromeTraceTest.scala  | 21 +++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/compiler/test/dotty/tools/dotc/profile/ChromeTraceTest.scala b/compiler/test/dotty/tools/dotc/profile/ChromeTraceTest.scala
index 07dc53da1f83..a5abf86b84c5 100644
--- a/compiler/test/dotty/tools/dotc/profile/ChromeTraceTest.scala
+++ b/compiler/test/dotty/tools/dotc/profile/ChromeTraceTest.scala
@@ -54,11 +54,11 @@ class ChromeTraceTest:
     val testStart = System.nanoTime()
     testTraceOutputs{ tracer =>
     tracer.traceDurationEventStart(cat = "test1", name = "event1")
-    LockSupport.parkNanos(2.millis.toNanos)
+    sleep(2.millis)
     tracer.traceDurationEventStart(cat = "test2", name = "event2", colour = "RED", pidSuffix = "pid-suffix")
-    LockSupport.parkNanos(4.millis.toNanos)
+    sleep(4.millis)
     tracer.traceDurationEventEnd(cat = "test2", name = "event2")
-    LockSupport.parkNanos(8.millis.toNanos)
+    sleep(8.millis)
     tracer.traceDurationEventEnd(cat = "test1", name = "event1", colour = "RED", pidSuffix = "pid-suffix")
   }{
     case """{"traceEvents":[""" ::
@@ -89,5 +89,18 @@ class ChromeTraceTest:
           assertTrue(ts4 >= ts3 + 8.millis.toMicros)
         case _ => fail("unreachable")
       }
+    }
+  }
+
+  private def sleep(duration: FiniteDuration): Unit = {
+    // A bit of additional precautions to ensure we don't continue execution to early
+    // Both LockSuppport and Thread.sleep can return earlier then expected (depending on OS)
+    var remainingNanos = duration.toNanos
+    val deadline = System.nanoTime() + remainingNanos
+    while
+      remainingNanos = deadline - System.nanoTime()
+      remainingNanos > 0
+    do
+      val millis = NANOSECONDS.toMillis(remainingNanos)
+      Thread.sleep(millis, (remainingNanos % 1.millis.toNanos).toInt)
   }
-}

From 27390b58da657536594867681c8f21fb4d4a63fa Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Fri, 8 Nov 2024 16:21:30 +0100
Subject: [PATCH 127/306] Remove unused variable [skip ci]

---
 compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala | 1 -
 1 file changed, 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala b/compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala
index a1bb5f9552c5..b8b40ab841c2 100644
--- a/compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala
+++ b/compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala
@@ -5,7 +5,6 @@ import scala.annotation.internal.sharable
 // Based on NameTransformer but dedicated for JSON encoding rules
 object JsonNameTransformer {
   private val nops = 128
-  private val ncodes = 26 * 26
 
   @sharable private val op2code = new Array[String](nops)
   private def enterOp(op: Char, code: String) = op2code(op.toInt) = code

From 407dacbe800b9768d971f89c7e6d57acae32cfa1 Mon Sep 17 00:00:00 2001
From: Lunfu Zhong <zhong.lunfu@gmail.com>
Date: Fri, 1 Nov 2024 15:29:49 +0800
Subject: [PATCH 128/306] Fix typos.

---
 docs/_docs/contributing/architecture/types.md | 2 +-
 docs/_docs/internals/gadts.md                 | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/_docs/contributing/architecture/types.md b/docs/_docs/contributing/architecture/types.md
index ed8995c08643..bf96d33b6a3c 100644
--- a/docs/_docs/contributing/architecture/types.md
+++ b/docs/_docs/contributing/architecture/types.md
@@ -108,7 +108,7 @@ Ground Type has no meaningful underlying type, typically it is the type of metho
 definitions, but also union types and intersection types, along with utility types of the
 compiler.
 
-Here's a diagram, serving as the mental model of the most important and distinct types available after the `typer` phase, derived from [dotty/tools/dotc/core/Types.scala][1]:
+Here's a diagram, serving as the mental model of the most important and distinct types available after the `typer` phase, derived from [Types.scala]:
 
 ```
 Type -+- proxy_type --+- NamedType --------+- TypeRef
diff --git a/docs/_docs/internals/gadts.md b/docs/_docs/internals/gadts.md
index 58f511c946c3..9a96043fc299 100644
--- a/docs/_docs/internals/gadts.md
+++ b/docs/_docs/internals/gadts.md
@@ -70,7 +70,7 @@ Right now, we record GADT constraints for:
 -   function/method type parameters
 -   class type parameters
 
-There is a branch on the way which will also record them for type members (so path-dependent types) and singleton types. It has a paper associated: "Implementing path-depepdent GADTs for Scala 3".
+There is a branch on the way which will also record them for type members (so path-dependent types) and singleton types. It has a paper associated: "Implementing path-dependent GADTs for Scala 3".
 
 ### What are necessary relationships? Any examples?
 

From a62a636fd92bf7d2161eae2de1705296d5526c2f Mon Sep 17 00:00:00 2001
From: Alden Torres <aldenml@cmaster.us>
Date: Sat, 9 Nov 2024 11:03:15 -0500
Subject: [PATCH 129/306] doc fix, removed repeated use of the word with

---
 .github/workflows/ci.yaml                                     | 2 +-
 compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala   | 2 +-
 compiler/src/dotty/tools/dotc/printing/Printer.scala          | 2 +-
 compiler/src/dotty/tools/dotc/typer/Applications.scala        | 2 +-
 docs/_docs/reference/experimental/better-fors.md              | 2 +-
 tests/pos-with-compiler-cc/backend/jvm/BCodeBodyBuilder.scala | 2 +-
 tests/pos-with-compiler-cc/dotc/printing/Printer.scala        | 2 +-
 tests/pos-with-compiler-cc/dotc/typer/Applications.scala      | 2 +-
 8 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 19405db61066..303922719b5b 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -1169,7 +1169,7 @@ jobs:
     needs: [build-msi-package]
     with:
       # Ensure that version starts with prefix 3.
-      # In the future it can be adapted to compare with with git tag or version set in the project/Build.scala
+      # In the future it can be adapted to compare with git tag or version set in the project/Build.scala
       version: "3."
       java-version: 8
 
diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala b/compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala
index 565ad72c0d9d..35b24ab57b00 100644
--- a/compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala
+++ b/compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala
@@ -1143,7 +1143,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
          *       - Every time when generating an ATHROW, a new basic block is started.
          *       - During classfile writing, such basic blocks are found to be dead: no branches go there
          *       - Eliminating dead code would probably require complex shifts in the output byte buffer
-         *       - But there's an easy solution: replace all code in the dead block with with
+         *       - But there's an easy solution: replace all code in the dead block with
          *         `nop; nop; ... nop; athrow`, making sure the bytecode size stays the same
          *       - The corresponding stack frame can be easily generated: on entering a dead the block,
          *         the frame requires a single Throwable on the stack.
diff --git a/compiler/src/dotty/tools/dotc/printing/Printer.scala b/compiler/src/dotty/tools/dotc/printing/Printer.scala
index 297dc31ea94a..9f485ee84cda 100644
--- a/compiler/src/dotty/tools/dotc/printing/Printer.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Printer.scala
@@ -71,7 +71,7 @@ abstract class Printer {
   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:
+  /** The name, possibly 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
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index 17be2acc7378..6bb95e20fcaf 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -1348,7 +1348,7 @@ trait Applications extends Compatibility {
       tree
   }
 
-  /** Is `tp` a unary function type or an overloaded type with with only unary function
+  /** Is `tp` a unary function type or an overloaded type with only unary function
    *  types as alternatives?
    */
   def isUnary(tp: Type)(using Context): Boolean = tp match {
diff --git a/docs/_docs/reference/experimental/better-fors.md b/docs/_docs/reference/experimental/better-fors.md
index 7add425caf51..a4c42c9fb380 100644
--- a/docs/_docs/reference/experimental/better-fors.md
+++ b/docs/_docs/reference/experimental/better-fors.md
@@ -8,7 +8,7 @@ The `betterFors` language extension improves the usability of `for`-comprehensio
 
 The extension is enabled by the language import `import scala.language.experimental.betterFors` or by setting the command line option `-language:experimental.betterFors`.
 
-The biggest user facing change is the new ability to start `for`-comprehensions with with aliases. This means that the following previously invalid code is now valid:
+The biggest user facing change is the new ability to start `for`-comprehensions with aliases. This means that the following previously invalid code is now valid:
 
 ```scala
 for
diff --git a/tests/pos-with-compiler-cc/backend/jvm/BCodeBodyBuilder.scala b/tests/pos-with-compiler-cc/backend/jvm/BCodeBodyBuilder.scala
index 6f067a0e5ef0..da6d213351b7 100644
--- a/tests/pos-with-compiler-cc/backend/jvm/BCodeBodyBuilder.scala
+++ b/tests/pos-with-compiler-cc/backend/jvm/BCodeBodyBuilder.scala
@@ -1103,7 +1103,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
          *       - Every time when generating an ATHROW, a new basic block is started.
          *       - During classfile writing, such basic blocks are found to be dead: no branches go there
          *       - Eliminating dead code would probably require complex shifts in the output byte buffer
-         *       - But there's an easy solution: replace all code in the dead block with with
+         *       - But there's an easy solution: replace all code in the dead block with
          *         `nop; nop; ... nop; athrow`, making sure the bytecode size stays the same
          *       - The corresponding stack frame can be easily generated: on entering a dead the block,
          *         the frame requires a single Throwable on the stack.
diff --git a/tests/pos-with-compiler-cc/dotc/printing/Printer.scala b/tests/pos-with-compiler-cc/dotc/printing/Printer.scala
index b9da874cf9ae..eff283b345ce 100644
--- a/tests/pos-with-compiler-cc/dotc/printing/Printer.scala
+++ b/tests/pos-with-compiler-cc/dotc/printing/Printer.scala
@@ -70,7 +70,7 @@ abstract class Printer extends Pure {
   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:
+  /** The name, possibly 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
diff --git a/tests/pos-with-compiler-cc/dotc/typer/Applications.scala b/tests/pos-with-compiler-cc/dotc/typer/Applications.scala
index aed6c55f8ad8..6ffbf0465120 100644
--- a/tests/pos-with-compiler-cc/dotc/typer/Applications.scala
+++ b/tests/pos-with-compiler-cc/dotc/typer/Applications.scala
@@ -1182,7 +1182,7 @@ trait Applications extends Compatibility {
       tree
   }
 
-  /** Is `tp` a unary function type or an overloaded type with with only unary function
+  /** Is `tp` a unary function type or an overloaded type with only unary function
    *  types as alternatives?
    */
   def isUnary(tp: Type)(using Context): Boolean = tp match {

From a1d7f5e02535e236e2d2378ade402a8a19c24a39 Mon Sep 17 00:00:00 2001
From: Eugene Flesselle <eugene@flesselle.net>
Date: Mon, 29 Apr 2024 12:07:54 +0200
Subject: [PATCH 130/306] Refine the bounds of the `Tuple.Filter` type lambda
 predicate ..

to only require it be defined on the elements of the tuple.

This is one of the ongoing proposed tuple improvements, addressing #19175.

As carefully pointed out by @sjrd, this _is_ a potential breaking change.
See tests/neg/tuple-filter-compat.scala for an example.

This is not an unprecedented change however,
the analogous improvements were made to `Tuple.{Map, FlatMap}` in 28a695ef.
---
 library/src/scala/Tuple.scala       |  2 +-
 tests/neg/tuple-filter-compat.scala | 12 ++++++++++++
 tests/pos/tuple-filter.scala        |  6 ++++++
 3 files changed, 19 insertions(+), 1 deletion(-)
 create mode 100644 tests/neg/tuple-filter-compat.scala

diff --git a/library/src/scala/Tuple.scala b/library/src/scala/Tuple.scala
index 8074fe3664e5..060f2b5492b8 100644
--- a/library/src/scala/Tuple.scala
+++ b/library/src/scala/Tuple.scala
@@ -166,7 +166,7 @@ object Tuple {
    *  ```
    *  @syntax markdown
    */
-  type Filter[Tup <: Tuple, P[_] <: Boolean] <: Tuple = Tup match {
+  type Filter[Tup <: Tuple, P[_ <: Union[Tup]] <: Boolean] <: Tuple = Tup match {
     case EmptyTuple => EmptyTuple
     case h *: t => P[h] match {
       case true => h *: Filter[t, P]
diff --git a/tests/neg/tuple-filter-compat.scala b/tests/neg/tuple-filter-compat.scala
new file mode 100644
index 000000000000..f50837fc1d4b
--- /dev/null
+++ b/tests/neg/tuple-filter-compat.scala
@@ -0,0 +1,12 @@
+
+type OldFilter[Tup <: Tuple, P[_] <: Boolean] = Nothing
+type NewFilter[Tup <: Tuple, P[_ <: Tuple.Union[Tup]] <: Boolean] = Nothing
+
+trait A:
+  type X >: OldFilter <: OldFilter
+
+trait B1 extends A:
+  type X = OldFilter // ok
+
+trait B2 extends A:
+  type X = NewFilter // error: breaking change
diff --git a/tests/pos/tuple-filter.scala b/tests/pos/tuple-filter.scala
index 2c9638b2e47b..f67518f171f0 100644
--- a/tests/pos/tuple-filter.scala
+++ b/tests/pos/tuple-filter.scala
@@ -1,10 +1,16 @@
+import scala.compiletime.ops.int.<
+
 type P[x] <: Boolean = x match {
   case 3 => false
   case _ => true
 }
+
 type RejectAll[x] = false
 
+type Pos[X <: Int] = 0 < X
+
 def Test =
   summon[Tuple.Filter[(1, 2, 3, 4), P] =:= (1, 2, 4)]
   summon[Tuple.Filter[(1, 2, 3, 4), RejectAll] =:= EmptyTuple]
   summon[Tuple.Filter[EmptyTuple, P] =:= EmptyTuple]
+  summon[Tuple.Filter[(1, -2, 3, -4), Pos] =:= (1, 3)]

From 16becd70ddc4308fa72e34b940e61c1bef015fd2 Mon Sep 17 00:00:00 2001
From: Eugene Flesselle <eugene@flesselle.net>
Date: Mon, 29 Jul 2024 16:19:01 +0200
Subject: [PATCH 131/306] Move `NonEmptyTuple` members into `Tuple`

Addressing #19175

The motivation for this has already been established, among other things:
- the corresponding type level operations already use `Tuple` as upper bound;
- the corresponding `NamedTuple` operations also do not make a distinction;
- these operations are no more unsafe than other operations already available
  on `Tuple`, such as `drop`

Note this should _not_ be a problem for binary compatibility,
as both `Tuple` and `NonEmptyTuple` are erased to `Product`s
(see `defn.specialErasure`).
---
 library/src/scala/Tuple.scala          | 52 +++++++++++++-------------
 library/src/scala/runtime/Tuples.scala |  8 ++--
 2 files changed, 29 insertions(+), 31 deletions(-)

diff --git a/library/src/scala/Tuple.scala b/library/src/scala/Tuple.scala
index 060f2b5492b8..40469df063d1 100644
--- a/library/src/scala/Tuple.scala
+++ b/library/src/scala/Tuple.scala
@@ -31,6 +31,30 @@ sealed trait Tuple extends Product {
   inline def *: [H, This >: this.type <: Tuple] (x: H): H *: This =
     runtime.Tuples.cons(x, this).asInstanceOf[H *: This]
 
+  /** Get the i-th element of this tuple.
+   *  Equivalent to productElement but with a precise return type.
+   */
+  inline def apply[This >: this.type <: Tuple](n: Int): Elem[This, n.type] =
+    runtime.Tuples.apply(this, n).asInstanceOf[Elem[This, n.type]]
+
+  /** Get the head of this tuple */
+  inline def head[This >: this.type <: Tuple]: Head[This] =
+    runtime.Tuples.apply(this, 0).asInstanceOf[Head[This]]
+
+  /** Get the initial part of the tuple without its last element */
+  inline def init[This >: this.type <: Tuple]: Init[This] =
+    runtime.Tuples.init(this).asInstanceOf[Init[This]]
+
+  /** Get the last of this tuple */
+  inline def last[This >: this.type <: Tuple]: Last[This] =
+    runtime.Tuples.last(this).asInstanceOf[Last[This]]
+
+  /** Get the tail of this tuple.
+   *  This operation is O(this.size)
+   */
+  inline def tail[This >: this.type <: Tuple]: Tail[This] =
+    runtime.Tuples.tail(this).asInstanceOf[Tail[This]]
+
   /** Return a new tuple by concatenating `this` tuple with `that` tuple.
    *  This operation is O(this.size + that.size)
    */
@@ -304,33 +328,7 @@ case object EmptyTuple extends Tuple {
 }
 
 /** Tuple of arbitrary non-zero arity */
-sealed trait NonEmptyTuple extends Tuple {
-  import Tuple.*
-
-  /** Get the i-th element of this tuple.
-   *  Equivalent to productElement but with a precise return type.
-   */
-  inline def apply[This >: this.type <: NonEmptyTuple](n: Int): Elem[This, n.type] =
-    runtime.Tuples.apply(this, n).asInstanceOf[Elem[This, n.type]]
-
-  /** Get the head of this tuple */
-  inline def head[This >: this.type <: NonEmptyTuple]: Head[This] =
-    runtime.Tuples.apply(this, 0).asInstanceOf[Head[This]]
-
-  /** Get the initial part of the tuple without its last element */
-  inline def init[This >: this.type <: NonEmptyTuple]: Init[This] =
-    runtime.Tuples.init(this).asInstanceOf[Init[This]]
-
-  /** Get the last of this tuple */
-  inline def last[This >: this.type <: NonEmptyTuple]: Last[This] =
-    runtime.Tuples.last(this).asInstanceOf[Last[This]]
-
-  /** Get the tail of this tuple.
-   *  This operation is O(this.size)
-   */
-  inline def tail[This >: this.type <: NonEmptyTuple]: Tail[This] =
-    runtime.Tuples.tail(this).asInstanceOf[Tail[This]]
-}
+sealed trait NonEmptyTuple extends Tuple
 
 @showAsInfix
 sealed abstract class *:[+H, +T <: Tuple] extends NonEmptyTuple
diff --git a/library/src/scala/runtime/Tuples.scala b/library/src/scala/runtime/Tuples.scala
index efb54c54d50b..66dc486d2a1d 100644
--- a/library/src/scala/runtime/Tuples.scala
+++ b/library/src/scala/runtime/Tuples.scala
@@ -350,7 +350,7 @@ object Tuples {
     }
   }
 
-  def tail(self: NonEmptyTuple): Tuple = (self: Any) match {
+  def tail(self: Tuple): Tuple = (self: Any) match {
     case xxl: TupleXXL => xxlTail(xxl)
     case _ => specialCaseTail(self)
   }
@@ -558,16 +558,16 @@ object Tuples {
     }
   }
 
-  def init(self: NonEmptyTuple): Tuple = (self: Any) match {
+  def init(self: Tuple): Tuple = (self: Any) match {
     case xxl: TupleXXL => xxlInit(xxl)
     case _ => specialCaseInit(self)
   }
 
-  def last(self: NonEmptyTuple): Any = (self: Any) match {
+  def last(self: Tuple): Any = (self: Any) match {
     case self: Product => self.productElement(self.productArity - 1)
   }
 
-  def apply(self: NonEmptyTuple, n: Int): Any =
+  def apply(self: Tuple, n: Int): Any =
     self.productElement(n)
 
   // Benchmarks showed that this is faster than doing (it1 zip it2).copyToArray(...)

From d9b8da5413cc564d7363024165957325d4b6893a Mon Sep 17 00:00:00 2001
From: HarrisL2 <harris.yh.lau@gmail.com>
Date: Mon, 11 Nov 2024 11:17:36 -0500
Subject: [PATCH 132/306] Check for open flag on objects

Fixes #21760
---
 compiler/src/dotty/tools/dotc/typer/Checking.scala | 2 ++
 tests/neg/i21760.scala                             | 1 +
 2 files changed, 3 insertions(+)
 create mode 100644 tests/neg/i21760.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
index 700bd483ff38..761e7cdab37c 100644
--- a/compiler/src/dotty/tools/dotc/typer/Checking.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -611,6 +611,8 @@ object Checking {
     val mods = mdef.mods
     def flagSourcePos(flag: FlagSet) =
       mods.mods.find(_.flags == flag).getOrElse(mdef).srcPos
+    if mods.is(Open) then
+      report.error(ModifierNotAllowedForDefinition(Open), flagSourcePos(Open))
     if mods.is(Abstract) then
       report.error(ModifierNotAllowedForDefinition(Abstract), flagSourcePos(Abstract))
     if mods.is(Sealed) then
diff --git a/tests/neg/i21760.scala b/tests/neg/i21760.scala
new file mode 100644
index 000000000000..625e03520dfb
--- /dev/null
+++ b/tests/neg/i21760.scala
@@ -0,0 +1 @@
+open object O // error
\ No newline at end of file

From 04934b77546bb2d1c64a702752161d2808db0610 Mon Sep 17 00:00:00 2001
From: Hamza Remmal <hamza@remmal.dev>
Date: Mon, 11 Nov 2024 17:48:35 +0100
Subject: [PATCH 133/306] fix: don't consider `into` as a soft-modifier

Co-authored-by: kasiaMarek <kasia@marek.net>
Co-authored-by: KacperFKorban <kacper.f.korban@gmail.com>
---
 compiler/src/dotty/tools/dotc/parsing/Tokens.scala | 2 +-
 tests/neg/i21786.check                             | 6 ++++++
 tests/neg/i21786.scala                             | 1 +
 tests/pos/i21635.scala                             | 6 ++++++
 4 files changed, 14 insertions(+), 1 deletion(-)
 create mode 100644 tests/neg/i21786.check
 create mode 100644 tests/neg/i21786.scala
 create mode 100644 tests/pos/i21635.scala

diff --git a/compiler/src/dotty/tools/dotc/parsing/Tokens.scala b/compiler/src/dotty/tools/dotc/parsing/Tokens.scala
index b0a533b2f1df..c78a336ecdf5 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Tokens.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Tokens.scala
@@ -297,7 +297,7 @@ object Tokens extends TokensCommon {
 
   final val closingParens = BitSet(RPAREN, RBRACKET, RBRACE)
 
-  final val softModifierNames = Set(nme.inline, nme.into, nme.opaque, nme.open, nme.transparent, nme.infix)
+  final val softModifierNames = Set(nme.inline, nme.opaque, nme.open, nme.transparent, nme.infix)
 
   def showTokenDetailed(token: Int): String = debugString(token)
 
diff --git a/tests/neg/i21786.check b/tests/neg/i21786.check
new file mode 100644
index 000000000000..47f7e2456c3d
--- /dev/null
+++ b/tests/neg/i21786.check
@@ -0,0 +1,6 @@
+-- [E103] Syntax Error: tests/neg/i21786.scala:1:0 ---------------------------------------------------------------------
+1 |into class X // error
+  |^^^^
+  |Illegal start of toplevel definition
+  |
+  | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/i21786.scala b/tests/neg/i21786.scala
new file mode 100644
index 000000000000..c5bb9c595d32
--- /dev/null
+++ b/tests/neg/i21786.scala
@@ -0,0 +1 @@
+into class X // error
diff --git a/tests/pos/i21635.scala b/tests/pos/i21635.scala
new file mode 100644
index 000000000000..dc0a8314c7d8
--- /dev/null
+++ b/tests/pos/i21635.scala
@@ -0,0 +1,6 @@
+class A(val into: Boolean) {
+  def m1(): Any =
+    into
+
+  def m2(): Int = 1
+}

From 46cd2565e1bc9d5b660bfc0218cdfc5834fa934e Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Mon, 11 Nov 2024 22:10:30 +0100
Subject: [PATCH 134/306] Allow discarding "Discarded non-Unit" warnings with
 `: Unit`
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: nmc.borst <1698211+nmcb@users.noreply.github.com>
Co-Authored-By: Jędrzej Rochala <48657087+rochala@users.noreply.github.com>
---
 .../dotty/tools/dotc/reporting/messages.scala |  4 ++--
 .../src/dotty/tools/dotc/typer/Typer.scala    | 22 +++++++++++++++----
 tests/neg-custom-args/captures/real-try.check |  2 +-
 tests/neg/i13091.check                        | 22 +++++++------------
 tests/neg/i13091.scala                        |  2 +-
 tests/neg/i18408a.check                       |  2 +-
 tests/neg/i18408b.check                       |  2 +-
 tests/neg/i18408c.check                       |  2 +-
 tests/neg/spaces-vs-tabs.check                |  6 -----
 tests/neg/spaces-vs-tabs.scala                |  2 +-
 tests/warn/21557.check                        | 18 +++++++++++++++
 tests/warn/21557.scala                        | 19 ++++++++++++++++
 tests/warn/i18722.check                       |  8 +++----
 tests/warn/nonunit-statement.check            | 20 ++++++++---------
 tests/warn/warn-value-discard.check           | 10 ++++-----
 15 files changed, 90 insertions(+), 51 deletions(-)
 create mode 100644 tests/warn/21557.check
 create mode 100644 tests/warn/21557.scala

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index 3b7fba1cb52d..1126e78ea62a 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2469,7 +2469,7 @@ class PureExpressionInStatementPosition(stat: untpd.Tree, val exprOwner: Symbol)
 class PureUnitExpression(stat: untpd.Tree, tpe: Type)(using Context)
   extends Message(PureUnitExpressionID) {
   def kind = MessageKind.PotentialIssue
-  def msg(using Context) = i"Discarded non-Unit value of type ${tpe.widen}. You may want to use `()`."
+  def msg(using Context) = i"Discarded non-Unit value of type ${tpe.widen}. Add `: Unit` to discard silently."
   def explain(using Context) =
     i"""As this expression is not of type Unit, it is desugared into `{ $stat; () }`.
        |Here the `$stat` expression is a pure statement that can be discarded.
@@ -3173,7 +3173,7 @@ class InlinedAnonClassWarning()(using Context)
 class ValueDiscarding(tp: Type)(using Context)
   extends Message(ValueDiscardingID):
     def kind = MessageKind.PotentialIssue
-    def msg(using Context) = i"discarded non-Unit value of type $tp"
+    def msg(using Context) = i"discarded non-Unit value of type ${tp.widen}. Add `: Unit` to discard silently."
     def explain(using Context) = ""
 
 class UnusedNonUnitValue(tp: Type)(using Context)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index bbd78b5dcc2e..3c32e9aea765 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -81,6 +81,9 @@ object Typer {
   /** Indicates that a definition was copied over from the parent refinements */
   val RefinementFromParent = new Property.StickyKey[Unit]
 
+  /** Indicates that an expression is explicitly ascribed to [[Unit]] type. */
+  val AscribedToUnit = new Property.StickyKey[Unit]
+
   /** An attachment on a Select node with an `apply` field indicating that the `apply`
    *  was inserted by the Typer.
    */
@@ -1193,7 +1196,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         else tpt
       val expr1 =
         if isWildcard then tree.expr.withType(underlyingTreeTpe.tpe)
-        else typed(tree.expr, underlyingTreeTpe.tpe.widenSkolem)
+        else
+          if underlyingTreeTpe.tpe.isRef(defn.UnitClass) then
+            untpd.unsplice(tree.expr).putAttachment(AscribedToUnit, ())
+          typed(tree.expr, underlyingTreeTpe.tpe.widenSkolem)
       assignType(cpy.Typed(tree)(expr1, tpt), underlyingTreeTpe)
         .withNotNullInfo(expr1.notNullInfo)
     }
@@ -3377,7 +3383,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       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)
+        val app = typedApply(desugar.binop(l, op, r).withAttachmentsFrom(tree), pt)
         if op.name.isRightAssocOperatorName && !ctx.mode.is(Mode.QuotedExprPattern) then
           val defs = new mutable.ListBuffer[Tree]
           def lift(app: Tree): Tree = (app: @unchecked) match
@@ -4581,9 +4587,14 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         // so will take the code path that decides on inlining
         val tree1 = adapt(tree, WildcardType, locked)
         checkStatementPurity(tree1)(tree, ctx.owner, isUnitExpr = true)
-        if (!ctx.isAfterTyper && !tree.isInstanceOf[Inlined] && ctx.settings.Whas.valueDiscard && !isThisTypeResult(tree)) {
+
+        if ctx.settings.Whas.valueDiscard
+           && !ctx.isAfterTyper
+           && !tree.isInstanceOf[Inlined]
+           && !isThisTypeResult(tree)
+           && !tree.hasAttachment(AscribedToUnit) then
           report.warning(ValueDiscarding(tree.tpe), tree.srcPos)
-        }
+
         return tpd.Block(tree1 :: Nil, unitLiteral)
       }
 
@@ -4839,6 +4850,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         // 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 _ if tree.hasAttachment(AscribedToUnit) =>
+        // The tree was ascribed to `Unit` explicitly to silence the warning.
+        ()
       case _ if isUnitExpr =>
         report.warning(PureUnitExpression(original, tree.tpe), original.srcPos)
       case _ =>
diff --git a/tests/neg-custom-args/captures/real-try.check b/tests/neg-custom-args/captures/real-try.check
index 7f8ab50bc222..6df092885384 100644
--- a/tests/neg-custom-args/captures/real-try.check
+++ b/tests/neg-custom-args/captures/real-try.check
@@ -1,7 +1,7 @@
 -- [E190] Potential Issue Warning: tests/neg-custom-args/captures/real-try.scala:38:4 ----------------------------------
 38 |  b.x
    |  ^^^
-   |  Discarded non-Unit value of type () -> Unit. You may want to use `()`.
+   |  Discarded non-Unit value of type () -> Unit. Add `: Unit` to discard silently.
    |
    | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/real-try.scala:14:2 -----------------------------------------------------------
diff --git a/tests/neg/i13091.check b/tests/neg/i13091.check
index 5cd793a9cfcb..bf8207d85e51 100644
--- a/tests/neg/i13091.check
+++ b/tests/neg/i13091.check
@@ -1,15 +1,9 @@
--- [E190] Potential Issue Warning: tests/neg/i13091.scala:7:17 ---------------------------------------------------------
-7 |def test: Unit = new Foo // error: class Foo is marked @experimental ...
-  |                 ^^^^^^^
-  |                 Discarded non-Unit value of type Foo. You may want to use `()`.
+-- Error: tests/neg/i13091.scala:7:16 ----------------------------------------------------------------------------------
+7 |def test = (new Foo): Unit // error: class Foo is marked @experimental ...
+  |                ^^^
+  |                class Foo is marked @experimental
   |
-  | longer explanation available when compiling with `-explain`
--- Error: tests/neg/i13091.scala:7:21 ----------------------------------------------------------------------------------
-7 |def test: Unit = new Foo // error: class Foo is marked @experimental ...
-  |                     ^^^
-  |                     class Foo is marked @experimental
-  |
-  |                     Experimental definition may only be used under experimental mode:
-  |                       1. in a definition marked as @experimental, or
-  |                       2. an experimental feature is imported at the package level, or
-  |                       3. compiling with the -experimental compiler flag.
+  |                Experimental definition may only be used under experimental mode:
+  |                  1. in a definition marked as @experimental, or
+  |                  2. an experimental feature is imported at the package level, or
+  |                  3. compiling with the -experimental compiler flag.
diff --git a/tests/neg/i13091.scala b/tests/neg/i13091.scala
index 549fdf6d0fae..8ee77efa37c1 100644
--- a/tests/neg/i13091.scala
+++ b/tests/neg/i13091.scala
@@ -4,4 +4,4 @@ import annotation.experimental
 
 @experimental class Foo
 
-def test: Unit = new Foo // error: class Foo is marked @experimental ...
+def test = (new Foo): Unit // error: class Foo is marked @experimental ...
diff --git a/tests/neg/i18408a.check b/tests/neg/i18408a.check
index ff278e6fe5cb..2fb701f90712 100644
--- a/tests/neg/i18408a.check
+++ b/tests/neg/i18408a.check
@@ -7,7 +7,7 @@
 -- [E190] Potential Issue Warning: tests/neg/i18408a.scala:3:15 --------------------------------------------------------
 3 |def test1 = fa(42)
   |               ^^
-  |               Discarded non-Unit value of type Int. You may want to use `()`.
+  |               Discarded non-Unit value of type Int. Add `: Unit` to discard silently.
   |
   | longer explanation available when compiling with `-explain`
 -- [E129] Potential Issue Warning: tests/neg/i18408a.scala:4:16 --------------------------------------------------------
diff --git a/tests/neg/i18408b.check b/tests/neg/i18408b.check
index 7c72833fe5ad..069c8345742b 100644
--- a/tests/neg/i18408b.check
+++ b/tests/neg/i18408b.check
@@ -7,7 +7,7 @@
 -- [E190] Potential Issue Warning: tests/neg/i18408b.scala:3:15 --------------------------------------------------------
 3 |def test1 = fa(42)
   |               ^^
-  |               Discarded non-Unit value of type Int. You may want to use `()`.
+  |               Discarded non-Unit value of type Int. Add `: Unit` to discard silently.
   |
   | longer explanation available when compiling with `-explain`
 -- [E129] Potential Issue Warning: tests/neg/i18408b.scala:4:16 --------------------------------------------------------
diff --git a/tests/neg/i18408c.check b/tests/neg/i18408c.check
index 078f42bb0006..994e6b499371 100644
--- a/tests/neg/i18408c.check
+++ b/tests/neg/i18408c.check
@@ -7,7 +7,7 @@
 -- [E190] Potential Issue Warning: tests/neg/i18408c.scala:3:15 --------------------------------------------------------
 3 |def test1 = fa(42)
   |               ^^
-  |               Discarded non-Unit value of type Int. You may want to use `()`.
+  |               Discarded non-Unit value of type Int. Add `: Unit` to discard silently.
   |
   | longer explanation available when compiling with `-explain`
 -- [E129] Potential Issue Warning: tests/neg/i18408c.scala:4:16 --------------------------------------------------------
diff --git a/tests/neg/spaces-vs-tabs.check b/tests/neg/spaces-vs-tabs.check
index f8374618f0fd..ce55267b0cce 100644
--- a/tests/neg/spaces-vs-tabs.check
+++ b/tests/neg/spaces-vs-tabs.check
@@ -28,9 +28,3 @@
    |	  The start of this line does not match any of the previous indentation widths.
    |	  Indentation width of current line : 1 tab, 2 spaces
    |	  This falls between previous widths: 1 tab and 1 tab, 4 spaces
--- [E190] Potential Issue Warning: tests/neg/spaces-vs-tabs.scala:13:7 -------------------------------------------------
-13 |	      1
-   |	      ^
-   |	      Discarded non-Unit value of type Int. You may want to use `()`.
-   |
-   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/spaces-vs-tabs.scala b/tests/neg/spaces-vs-tabs.scala
index 4f48d784eb7d..eafc5209ca47 100644
--- a/tests/neg/spaces-vs-tabs.scala
+++ b/tests/neg/spaces-vs-tabs.scala
@@ -10,6 +10,6 @@ object Test:
 	object Test2:
 
 	    if true then
-	      1
+	      ()
 	  else 2 // error
 
diff --git a/tests/warn/21557.check b/tests/warn/21557.check
new file mode 100644
index 000000000000..1753960b852a
--- /dev/null
+++ b/tests/warn/21557.check
@@ -0,0 +1,18 @@
+-- [E190] Potential Issue Warning: tests/warn/21557.scala:9:16 ---------------------------------------------------------
+9 |  val x: Unit = 1 + 1 // warn
+  |                ^^^^^
+  |                Discarded non-Unit value of type Int. Add `: Unit` to discard silently.
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E176] Potential Issue Warning: tests/warn/21557.scala:10:2 ---------------------------------------------------------
+10 |  1 + 1 // warn
+   |  ^^^^^
+   |  unused value of type (2 : Int)
+-- [E175] Potential Issue Warning: tests/warn/21557.scala:15:52 --------------------------------------------------------
+15 |  val x1: Unit = new Assertion("another").shouldPass() // warn (enabled by -Wvalue-discard)
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                 discarded non-Unit value of type Assertion. Add `: Unit` to discard silently.
+-- [E176] Potential Issue Warning: tests/warn/21557.scala:16:41 --------------------------------------------------------
+16 |  new Assertion("yet another").shouldPass() // warn (enabled by -Wnonunit-statement)
+   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |  unused value of type Assertion
diff --git a/tests/warn/21557.scala b/tests/warn/21557.scala
new file mode 100644
index 000000000000..ed7028b6a48a
--- /dev/null
+++ b/tests/warn/21557.scala
@@ -0,0 +1,19 @@
+//> using options -Wvalue-discard -Wnonunit-statement
+
+class Assertion(assert: => Any):
+  def shouldPass(): Assertion = ???
+
+def test: Unit =
+  1 + 1: Unit
+  (1 + 1): Unit
+  val x: Unit = 1 + 1 // warn
+  1 + 1 // warn
+  val y: Int = 1 + 1
+
+  new Assertion("").shouldPass(): Unit
+  (new Assertion("").shouldPass()): Unit
+  val x1: Unit = new Assertion("another").shouldPass() // warn (enabled by -Wvalue-discard)
+  new Assertion("yet another").shouldPass() // warn (enabled by -Wnonunit-statement)
+  val y1: Assertion = new Assertion("another other").shouldPass()
+
+  ()
diff --git a/tests/warn/i18722.check b/tests/warn/i18722.check
index 4fae07e15204..4b32cb418167 100644
--- a/tests/warn/i18722.check
+++ b/tests/warn/i18722.check
@@ -1,7 +1,7 @@
 -- [E190] Potential Issue Warning: tests/warn/i18722.scala:3:15 --------------------------------------------------------
 3 |def f1: Unit = null // warn
   |               ^^^^
-  |               Discarded non-Unit value of type Null. You may want to use `()`.
+  |               Discarded non-Unit value of type Null. Add `: Unit` to discard silently.
   |---------------------------------------------------------------------------------------------------------------------
   | Explanation (enabled by `-explain`)
   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -12,7 +12,7 @@
 -- [E190] Potential Issue Warning: tests/warn/i18722.scala:4:15 --------------------------------------------------------
 4 |def f2: Unit = 1 // warn
   |               ^
-  |               Discarded non-Unit value of type Int. You may want to use `()`.
+  |               Discarded non-Unit value of type Int. Add `: Unit` to discard silently.
   |---------------------------------------------------------------------------------------------------------------------
   | Explanation (enabled by `-explain`)
   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -23,7 +23,7 @@
 -- [E190] Potential Issue Warning: tests/warn/i18722.scala:5:15 --------------------------------------------------------
 5 |def f3: Unit = "a" // warn
   |               ^^^
-  |               Discarded non-Unit value of type String. You may want to use `()`.
+  |               Discarded non-Unit value of type String. Add `: Unit` to discard silently.
   |---------------------------------------------------------------------------------------------------------------------
   | Explanation (enabled by `-explain`)
   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -34,7 +34,7 @@
 -- [E190] Potential Issue Warning: tests/warn/i18722.scala:7:15 --------------------------------------------------------
 7 |def f4: Unit = i // warn
   |               ^
-  |               Discarded non-Unit value of type Int. You may want to use `()`.
+  |               Discarded non-Unit value of type Int. Add `: Unit` to discard silently.
   |---------------------------------------------------------------------------------------------------------------------
   | Explanation (enabled by `-explain`)
   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
diff --git a/tests/warn/nonunit-statement.check b/tests/warn/nonunit-statement.check
index 742a9fe911e8..7e7939e1c163 100644
--- a/tests/warn/nonunit-statement.check
+++ b/tests/warn/nonunit-statement.check
@@ -27,15 +27,15 @@
 -- [E175] Potential Issue Warning: tests/warn/nonunit-statement.scala:58:19 --------------------------------------------
 58 |    if (!isEmpty) f(a)      // warn (if)
    |                  ^^^^
-   |                  discarded non-Unit value of type U
+   |                  discarded non-Unit value of type U. Add `: Unit` to discard silently.
 -- [E175] Potential Issue Warning: tests/warn/nonunit-statement.scala:62:7 ---------------------------------------------
 62 |      f(a)                  // warn (if)
    |      ^^^^
-   |      discarded non-Unit value of type Boolean
+   |      discarded non-Unit value of type Boolean. Add `: Unit` to discard silently.
 -- [E175] Potential Issue Warning: tests/warn/nonunit-statement.scala:73:25 --------------------------------------------
 73 |    if (!fellback) action(z)  // warn (if)
    |                   ^^^^^^^^^
-   |                   discarded non-Unit value of type U
+   |                   discarded non-Unit value of type U. Add `: Unit` to discard silently.
 -- [E176] Potential Issue Warning: tests/warn/nonunit-statement.scala:79:6 ---------------------------------------------
 79 |      g   // warn block statement
    |      ^
@@ -43,7 +43,7 @@
 -- [E175] Potential Issue Warning: tests/warn/nonunit-statement.scala:81:6 ---------------------------------------------
 81 |      g   // warn (if)
    |      ^
-   |      discarded non-Unit value of type (g : => Int)
+   |      discarded non-Unit value of type Int. Add `: Unit` to discard silently.
 -- [E176] Potential Issue Warning: tests/warn/nonunit-statement.scala:84:6 ---------------------------------------------
 84 |      g   // warn
    |      ^
@@ -51,7 +51,7 @@
 -- [E175] Potential Issue Warning: tests/warn/nonunit-statement.scala:86:6 ---------------------------------------------
 86 |      g   // warn
    |      ^
-   |      discarded non-Unit value of type (g : => Int)
+   |      discarded non-Unit value of type Int. Add `: Unit` to discard silently.
 -- [E176] Potential Issue Warning: tests/warn/nonunit-statement.scala:96:4 ---------------------------------------------
  96 |    if (b) {          // warn, at least one branch looks interesting
     |    ^
@@ -70,20 +70,20 @@
 -- [E175] Potential Issue Warning: tests/warn/nonunit-statement.scala:126:37 -------------------------------------------
 126 |    if (start.length != 0) jsb.append(start) // warn (value-discard)
     |                           ^^^^^^^^^^^^^^^^^
-    |                           discarded non-Unit value of type StringBuilder
+    |                           discarded non-Unit value of type StringBuilder. Add `: Unit` to discard silently.
 -- [E175] Potential Issue Warning: tests/warn/nonunit-statement.scala:132:18 -------------------------------------------
 132 |        jsb.append(it.next()) // warn (value-discard)
     |        ^^^^^^^^^^^^^^^^^^^^^
-    |        discarded non-Unit value of type StringBuilder
+    |        discarded non-Unit value of type StringBuilder. Add `: Unit` to discard silently.
 -- [E175] Potential Issue Warning: tests/warn/nonunit-statement.scala:135:35 -------------------------------------------
 135 |    if (end.length != 0) jsb.append(end) // warn (value-discard)
     |                         ^^^^^^^^^^^^^^^
-    |                         discarded non-Unit value of type StringBuilder
+    |                         discarded non-Unit value of type StringBuilder. Add `: Unit` to discard silently.
 -- [E175] Potential Issue Warning: tests/warn/nonunit-statement.scala:141:14 -------------------------------------------
 141 |      b.append(it.next()) // warn (value-discard)
     |      ^^^^^^^^^^^^^^^^^^^
-    |      discarded non-Unit value of type StringBuilder
+    |      discarded non-Unit value of type StringBuilder. Add `: Unit` to discard silently.
 -- [E175] Potential Issue Warning: tests/warn/nonunit-statement.scala:146:30 -------------------------------------------
 146 |    while (it.hasNext) it.next()  // warn
     |                       ^^^^^^^^^
-    |                       discarded non-Unit value of type String
+    |                       discarded non-Unit value of type String. Add `: Unit` to discard silently.
diff --git a/tests/warn/warn-value-discard.check b/tests/warn/warn-value-discard.check
index ca6fedb29053..dcd6d62c00e0 100644
--- a/tests/warn/warn-value-discard.check
+++ b/tests/warn/warn-value-discard.check
@@ -1,20 +1,20 @@
 -- [E175] Potential Issue Warning: tests/warn/warn-value-discard.scala:27:36 -------------------------------------------
 27 |    mutable.Set.empty[String].remove("") // warn
    |    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |    discarded non-Unit value of type Boolean
+   |    discarded non-Unit value of type Boolean. Add `: Unit` to discard silently.
 -- [E175] Potential Issue Warning: tests/warn/warn-value-discard.scala:39:41 -------------------------------------------
 39 |    mutable.Set.empty[String].subtractOne("") // warn
    |    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |    discarded non-Unit value of type scala.collection.mutable.Set[String]
+   |    discarded non-Unit value of type scala.collection.mutable.Set[String]. Add `: Unit` to discard silently.
 -- [E175] Potential Issue Warning: tests/warn/warn-value-discard.scala:59:4 --------------------------------------------
 59 |    mutable.Set.empty[String] += "" // warn
    |    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |    discarded non-Unit value of type scala.collection.mutable.Set[String]
+   |    discarded non-Unit value of type scala.collection.mutable.Set[String]. Add `: Unit` to discard silently.
 -- [E175] Potential Issue Warning: tests/warn/warn-value-discard.scala:15:35 -------------------------------------------
 15 |  firstThing().map(_ => secondThing()) // warn
    |                        ^^^^^^^^^^^^^
-   |                        discarded non-Unit value of type Either[Failed, Unit]
+   |                        discarded non-Unit value of type Either[Failed, Unit]. Add `: Unit` to discard silently.
 -- [E175] Potential Issue Warning: tests/warn/warn-value-discard.scala:18:35 -------------------------------------------
 18 |  firstThing().map(_ => secondThing()) // warn
    |                        ^^^^^^^^^^^^^
-   |                        discarded non-Unit value of type Either[Failed, Unit]
+   |                        discarded non-Unit value of type Either[Failed, Unit]. Add `: Unit` to discard silently.

From 14bf406e02488e7c333a94989cbc1f7fff07b625 Mon Sep 17 00:00:00 2001
From: Eugene Flesselle <eugene@flesselle.net>
Date: Tue, 12 Nov 2024 10:12:29 +0100
Subject: [PATCH 135/306] Test reduction of Tuple.Zip

---
 tests/pos/tuple-zip.scala | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 tests/pos/tuple-zip.scala

diff --git a/tests/pos/tuple-zip.scala b/tests/pos/tuple-zip.scala
new file mode 100644
index 000000000000..980dff9433a6
--- /dev/null
+++ b/tests/pos/tuple-zip.scala
@@ -0,0 +1,20 @@
+
+import scala.Tuple.Zip
+
+type A
+type B
+type C
+
+def Test =
+
+  summon[Zip[A *: B *: C *: EmptyTuple, C *: B *: A *: EmptyTuple] =:= (A, C) *: (B, B) *: (C, A) *: EmptyTuple]
+
+  summon[Zip[A *: B *: EmptyTuple, C *: B *: A *: EmptyTuple] =:= (A, C) *: (B, B) *: EmptyTuple]
+  summon[Zip[A *: B *: C *: EmptyTuple, C *: B *: EmptyTuple] =:= (A, C) *: (B, B) *: EmptyTuple]
+
+  summon[Zip[A *: B *: C *: Tuple, C *: B *: A *: Tuple] =:= (A, C) *: (B, B) *: (C, A) *: Zip[Tuple, Tuple]]
+  summon[Zip[A *: B *: C *: Tuple, C *: B *: A *: Tuple] <:< (A, C) *: (B, B) *: (C, A) *: Tuple]
+
+  summon[Zip[A *: B *: Tuple, C *: B *: A *: Tuple] =:= (A, C) *: (B, B) *: Zip[Tuple, A *: Tuple]]
+  summon[Zip[A *: B *: NonEmptyTuple, C *: B *: A *: Tuple] =:= (A, C) *: (B, B) *: Zip[NonEmptyTuple, A *: Tuple]]
+  summon[Zip[A *: B *: EmptyTuple, C *: B *: A *: Tuple] =:= (A, C) *: (B, B) *: EmptyTuple]

From 7db83c547b6e950fe2ad28fdd3007f8f8cb0bd35 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Sun, 1 Sep 2024 23:57:29 +0100
Subject: [PATCH 136/306] Fix pkg obj prefix of opaque tp ext meth

There is use of `makePackageObjPrefixExplicit` within `accessibleType`,
which is called on the result of findRef in typedIdent.  But in
`tryExtension` it's no such use.  We could fix it in the usage of the
results in `tryExtension`, but I thought perhaps we could fix it for all
call sites, by handling it within findRef.
---
 .../src/dotty/tools/dotc/typer/Typer.scala    |  4 ++--
 tests/pos/i18097.1.scala                      | 22 +++++++++++++++++++
 tests/pos/i18097.2.scala                      | 13 +++++++++++
 tests/pos/i18097.2.works.scala                | 13 +++++++++++
 tests/pos/i18097.3/Opaque.scala               |  9 ++++++++
 tests/pos/i18097.3/Test.scala                 | 13 +++++++++++
 tests/pos/i18097.orig.scala                   | 20 +++++++++++++++++
 7 files changed, 92 insertions(+), 2 deletions(-)
 create mode 100644 tests/pos/i18097.1.scala
 create mode 100644 tests/pos/i18097.2.scala
 create mode 100644 tests/pos/i18097.2.works.scala
 create mode 100644 tests/pos/i18097.3/Opaque.scala
 create mode 100644 tests/pos/i18097.3/Test.scala
 create mode 100644 tests/pos/i18097.orig.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 817e7baf1c8c..8a633efc1021 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -344,7 +344,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
               // so we ignore that import.
               if reallyExists(denot) && !isScalaJsPseudoUnion then
                 if unimported.isEmpty || !unimported.contains(pre.termSymbol) then
-                  return pre.select(name, denot)
+                  return pre.select(name, denot).makePackageObjPrefixExplicit
           case _ =>
             if imp.importSym.isCompleting then
               report.warning(i"cyclic ${imp.importSym}, ignored", pos)
@@ -504,7 +504,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                       defDenot.symbol.owner
                     else
                       curOwner
-                  effectiveOwner.thisType.select(name, defDenot)
+                  effectiveOwner.thisType.select(name, defDenot).makePackageObjPrefixExplicit
                 }
               if !curOwner.is(Package) || isDefinedInCurrentUnit(defDenot) then
                 result = checkNewOrShadowed(found, Definition) // no need to go further out, we found highest prec entry
diff --git a/tests/pos/i18097.1.scala b/tests/pos/i18097.1.scala
new file mode 100644
index 000000000000..b7b57467e3b0
--- /dev/null
+++ b/tests/pos/i18097.1.scala
@@ -0,0 +1,22 @@
+opaque type Pos = Double
+
+object Pos:
+  extension (x: Pos)
+    def mult1(y: Pos): Pos = x * y
+
+extension (x: Pos)
+  def mult2(y: Pos): Pos = x * y
+
+class Test:
+  def test(key: String, a: Pos, b: Pos): Unit =
+    val tup1 = new Tuple1(Pos.mult1(a)(b))
+    val res1: Pos = tup1._1
+
+    val tup2 = new Tuple1(a.mult1(b))
+    val res2: Pos = tup2._1
+
+    val tup3 = new Tuple1(mult2(a)(b))
+    val res3: Pos = tup3._1
+
+    val tup4 = new Tuple1(a.mult2(b))
+    val res4: Pos = tup4._1 // was error: Found: (tup4._4 : Double) Required: Pos
diff --git a/tests/pos/i18097.2.scala b/tests/pos/i18097.2.scala
new file mode 100644
index 000000000000..c676479aab42
--- /dev/null
+++ b/tests/pos/i18097.2.scala
@@ -0,0 +1,13 @@
+opaque type Namespace = List[String]
+
+object Namespace:
+  def apply(head: String): Namespace = List(head)
+
+extension (ns: Namespace)
+  def appended(segment: String): Namespace = ns.appended(segment)
+
+object Main:
+  def main(args: Array[String]): Unit =
+    val a: Namespace = Namespace("a")
+      .appended("B")
+      .appended("c") // was error: Found: List[String] Required: Namespace
diff --git a/tests/pos/i18097.2.works.scala b/tests/pos/i18097.2.works.scala
new file mode 100644
index 000000000000..3ba8e056a4a5
--- /dev/null
+++ b/tests/pos/i18097.2.works.scala
@@ -0,0 +1,13 @@
+object Main:
+  opaque type Namespace = List[String]
+
+  object Namespace:
+    def apply(head: String): Namespace = List(head)
+
+  extension (ns: Namespace)
+    def appended(segment: String): Namespace = ns.appended(segment)
+
+  def main(args: Array[String]): Unit =
+    val a: Namespace = Namespace("a")
+      .appended("B")
+      .appended("c")
diff --git a/tests/pos/i18097.3/Opaque.scala b/tests/pos/i18097.3/Opaque.scala
new file mode 100644
index 000000000000..cb9c9eaedfb3
--- /dev/null
+++ b/tests/pos/i18097.3/Opaque.scala
@@ -0,0 +1,9 @@
+package test
+
+type Foo = Unit
+val bar: Foo = ()
+
+opaque type Opaque = Unit
+
+extension (foo: Foo)
+  def go: Option[Opaque] = ???
diff --git a/tests/pos/i18097.3/Test.scala b/tests/pos/i18097.3/Test.scala
new file mode 100644
index 000000000000..38f2199944c2
--- /dev/null
+++ b/tests/pos/i18097.3/Test.scala
@@ -0,0 +1,13 @@
+package test
+
+final case class Test(value: Opaque)
+
+def test: Test =
+  bar.go match
+    case Some(value) => Test(value) // was error: Found: (value : Unit) Required: test.Opaque
+    case _           => ???
+
+def test2: Test =
+  go(bar) match
+    case Some(value) => Test(value)
+    case _           => ???
diff --git a/tests/pos/i18097.orig.scala b/tests/pos/i18097.orig.scala
new file mode 100644
index 000000000000..092a904f6de4
--- /dev/null
+++ b/tests/pos/i18097.orig.scala
@@ -0,0 +1,20 @@
+opaque type PositiveNumber = Double
+
+object PositiveNumber:
+  extension (x: PositiveNumber)
+    def mult1(other: PositiveNumber): PositiveNumber =
+      x * other
+
+extension (x: PositiveNumber)
+  def mult2(other: PositiveNumber): PositiveNumber =
+    x * other
+
+object Test:
+  def multMap1[A](x: Map[A, PositiveNumber], num: PositiveNumber): Map[A, PositiveNumber] = x.map((key, value) => key -> value.mult1(num)).toMap
+
+  def multMap2[A](x: Map[A, PositiveNumber], num: PositiveNumber): Map[A, PositiveNumber] = x.map((key, value) => key -> value.mult2(num)).toMap // was error
+//                                                                                                                                              ^
+//                                             Cannot prove that (A, Double) <:< (A, V2).
+//
+//                                             where:    V2 is a type variable with constraint <: PositiveNumber
+  def multMap2_2[A](x: Map[A, PositiveNumber], num: PositiveNumber): Map[A, PositiveNumber] = x.map((key, value) => key -> mult2(value)(num)).toMap

From 2c0d6dfd5dbb1f962713fddd06d080df4c8ab8ce Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Fri, 25 Oct 2024 12:32:45 +0100
Subject: [PATCH 137/306] Remove tvars in normalizedCompatible via instantiate

Use a higher-level method.
---
 compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
index 9a94c50deb7f..85f44ead5f28 100644
--- a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -73,10 +73,9 @@ object ProtoTypes {
             if result && (ctx.typerState.constraint ne newctx.typerState.constraint) then
               // Remove all type lambdas and tvars introduced by testCompat
               for tvar <- newctx.typerState.ownedVars do
-                val tl = tvar.origin.binder
-                newctx.typerState.ownedVars -= tvar
-                if newctx.typerState.constraint.contains(tl) then
-                  newctx.typerState.constraint = newctx.typerState.constraint.remove(tl)(using newctx)
+                inContext(newctx):
+                  if !tvar.isInstantiated then
+                    tvar.instantiate(fromBelow = false) // any direction
 
               // commit any remaining changes in typer state
               newctx.typerState.commit()

From fb8389390a7db2f06f41fe2f3d7a9c2fcdec6bdd Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 12 Nov 2024 11:24:29 +0000
Subject: [PATCH 138/306] Fix Any#className decorator on null

---
 compiler/src/dotty/tools/dotc/core/Decorators.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Decorators.scala b/compiler/src/dotty/tools/dotc/core/Decorators.scala
index 29d4b3fa4052..96a2d45db80d 100644
--- a/compiler/src/dotty/tools/dotc/core/Decorators.scala
+++ b/compiler/src/dotty/tools/dotc/core/Decorators.scala
@@ -292,7 +292,7 @@ object Decorators {
       case _ => String.valueOf(x).nn
 
     /** Returns the simple class name of `x`. */
-    def className: String = x.getClass.getSimpleName.nn
+    def className: String = if x == null then "<null>" else x.getClass.getSimpleName.nn
 
   extension [T](x: T)
     def assertingErrorsReported(using Context): T = {

From 3d79d407aff7cbcf70d8736459c231e9b73d55dd Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 12 Nov 2024 11:58:38 +0000
Subject: [PATCH 139/306] (Re-)Drop inaccessible subclasses from
 refineUsingParent

This reverts commit cecd05356beecd232053d4c593af54bcc12cad0e.
---
 compiler/src/dotty/tools/dotc/core/TypeOps.scala |  6 +++++-
 tests/pos/i21790.scala                           | 14 ++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i21790.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
index 2403a6e22bc6..79eac7bde38d 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -930,7 +930,11 @@ object TypeOps:
       for tp <- mixins.reverseIterator do
         protoTp1 <:< tp
       maximizeType(protoTp1, NoSpan)
-      wildApprox(protoTp1)
+      val inst = wildApprox(protoTp1)
+      if !inst.classSymbol.exists then
+        // E.g. i21790, can't instantiate S#CA as a subtype of O.A, because O.CA isn't accessible
+        NoType
+      else inst
     }
 
     if (protoTp1 <:< tp2) instantiate()
diff --git a/tests/pos/i21790.scala b/tests/pos/i21790.scala
new file mode 100644
index 000000000000..0cc7db935ac7
--- /dev/null
+++ b/tests/pos/i21790.scala
@@ -0,0 +1,14 @@
+package p
+
+trait S:
+  sealed trait A
+  private class CA() extends A
+
+object O extends S
+
+trait T
+
+class Test:
+  def f(e: T) = e match
+    case _: O.A =>
+    case _      =>

From 21e5f3c40a156043622f2d400e2cb51cc138bab9 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 12 Nov 2024 12:01:35 +0000
Subject: [PATCH 140/306] Tweak refineUsingParent drop conditions

In tests/pos/i21790.scala, O.A has no class symbol, because it's an
inaccessible private class of S.  But in tests/warn/i21860.scala,
Shape.Triangle doesn't have a "classSymbol" because it has multiple -
Shape and Corners.  So use .classSymbols.isEmpty instead of
!.classSymbol.exists
---
 compiler/src/dotty/tools/dotc/core/TypeOps.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
index 79eac7bde38d..697e50c6a2a8 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -931,7 +931,7 @@ object TypeOps:
         protoTp1 <:< tp
       maximizeType(protoTp1, NoSpan)
       val inst = wildApprox(protoTp1)
-      if !inst.classSymbol.exists then
+      if inst.classSymbols.isEmpty then
         // E.g. i21790, can't instantiate S#CA as a subtype of O.A, because O.CA isn't accessible
         NoType
       else inst

From 55d2bd716767a810fe059204c3e026c6f9ba420f Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wojciech.mazur95@gmail.com>
Date: Tue, 12 Nov 2024 15:34:57 +0100
Subject: [PATCH 141/306] Apply suggestions from code review

Co-authored-by: Matt Bovel <matthieu@bovel.net>
---
 compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala b/compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala
index b8b40ab841c2..8777a95c33cf 100644
--- a/compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala
+++ b/compiler/src/dotty/tools/dotc/profile/JsonNameTransformer.scala
@@ -30,7 +30,7 @@ object JsonNameTransformer {
           buf.append(name.subSequence(0, i))
         }
         buf.append(op2code(c.toInt))
-      } else if (c <= 0x1F || c > 0x7F) {
+      } else if (c <= 0x1F || c >= 0x7F) {
         if (buf eq null) {
           buf = new StringBuilder()
           buf.append(name.subSequence(0, i))

From d05e60023c890dc8a7ba41133fb4351f7057eeeb Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Tue, 12 Nov 2024 17:04:09 +0100
Subject: [PATCH 142/306] Don't peoject nested wildcard pattern to nullable

---
 .../dotty/tools/dotc/transform/patmat/Space.scala  | 14 +++++---------
 tests/warn/i20121.scala                            |  4 ++--
 tests/warn/i20122.scala                            |  2 +-
 tests/warn/i20123.scala                            |  2 +-
 4 files changed, 9 insertions(+), 13 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 7410d617c4a0..1ee402deded0 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -337,13 +337,6 @@ object SpaceEngine {
     case pat: Ident if isBackquoted(pat) =>
       Typ(pat.tpe, decomposed = false)
 
-    case Ident(nme.WILDCARD) =>
-      val tp = pat.tpe.stripAnnots.widenSkolem
-      val isNullable = tp.isInstanceOf[FlexibleType] || tp.classSymbol.isNullableClass
-      val tpSpace = Typ(erase(tp, isValue = true), decomposed = false)
-      if isNullable then Or(tpSpace :: nullSpace :: Nil)
-      else tpSpace
-
     case Ident(_) | Select(_, _) =>
       Typ(erase(pat.tpe.stripAnnots.widenSkolem, isValue = true), decomposed = false)
 
@@ -716,7 +709,6 @@ object SpaceEngine {
           else NoType
         }.filter(_.exists)
         parts
-      case tp: FlexibleType => List(tp.underlying, ConstantType(Constant(null)))
       case _ => ListOfNoType
     end rec
 
@@ -939,11 +931,15 @@ object SpaceEngine {
       then project(OrType(selTyp, ConstantType(Constant(null)), soft = false))
       else project(selTyp)
     var hadNullOnly = false
+    def projectPat(pat: Tree): Space =
+      // Project toplevel wildcard pattern to nullable
+      if isNullable && isWildcardArg(pat) then Or(project(pat) :: nullSpace :: Nil)
+      else project(pat)
     @tailrec def recur(cases: List[CaseDef], prevs: List[Space], deferred: List[Tree]): Unit =
       cases match
         case Nil =>
         case CaseDef(pat, guard, _) :: rest =>
-          val curr = trace(i"project($pat)")(project(pat))
+          val curr = trace(i"project($pat)")(projectPat(pat))
           val covered = trace("covered")(simplify(intersect(curr, targetSpace)))
           val prev = trace("prev")(simplify(Or(prevs)))
           if prev == Empty && covered == Empty then // defer until a case is reachable
diff --git a/tests/warn/i20121.scala b/tests/warn/i20121.scala
index b8402fa808ac..ce8e3e4d74f6 100644
--- a/tests/warn/i20121.scala
+++ b/tests/warn/i20121.scala
@@ -5,8 +5,8 @@ case class CC_B[A](a: A) extends T_A[A, X]
 
 val v_a: T_A[X, X] = CC_B(null)
 val v_b = v_a match
-  case CC_B(_) => 0
-  case _       => 1 // warn: null only
+  case CC_B(_) => 0 // warn: unreachable
+  case _       => 1
     // for CC_B[A] to match T_A[X, X]
     // A := X
     // so require X, aka T_A[Byte, Byte]
diff --git a/tests/warn/i20122.scala b/tests/warn/i20122.scala
index d035a18d3b09..50da42a5926c 100644
--- a/tests/warn/i20122.scala
+++ b/tests/warn/i20122.scala
@@ -7,7 +7,7 @@ case class CC_E(a: CC_C[Char, Byte])
 
 val v_a: T_B[Int, CC_A] = CC_B(CC_E(CC_C(null)))
 val v_b = v_a match
-  case CC_B(CC_E(CC_C(_))) => 0
+  case CC_B(CC_E(CC_C(_))) => 0 // warn: unreachable
   case _                   => 1
     // for CC_B[A, C] to match T_B[C, CC_A]
     // C <: Int, ok
diff --git a/tests/warn/i20123.scala b/tests/warn/i20123.scala
index 0af7aba5a3a5..32de903210b2 100644
--- a/tests/warn/i20123.scala
+++ b/tests/warn/i20123.scala
@@ -8,7 +8,7 @@ case class CC_G[A, C](c: C) extends T_A[A, C]
 val v_a: T_A[Boolean, T_B[Boolean]] = CC_G(null)
 val v_b = v_a match {
   case CC_D()  => 0
-  case CC_G(_) => 1
+  case CC_G(_) => 1 // warn: unreachable
     // for CC_G[A, C] to match T_A[Boolean, T_B[Boolean]]
     // A := Boolean, which is ok
     // C := T_B[Boolean],

From 0d5e014c7532d63e44046ae5bed6094810316584 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Wed, 13 Nov 2024 11:18:25 +0100
Subject: [PATCH 143/306] Update test

---
 tests/patmat/i12530.check | 1 +
 tests/patmat/null.check   | 2 +-
 tests/patmat/null.scala   | 1 +
 3 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/tests/patmat/i12530.check b/tests/patmat/i12530.check
index b0605bcd95e5..636347516cbc 100644
--- a/tests/patmat/i12530.check
+++ b/tests/patmat/i12530.check
@@ -1 +1,2 @@
 6: Match case Unreachable
+14: Match case Unreachable
diff --git a/tests/patmat/null.check b/tests/patmat/null.check
index da081e6b56c0..3b860ddfd850 100644
--- a/tests/patmat/null.check
+++ b/tests/patmat/null.check
@@ -1,4 +1,4 @@
 6: Match case Unreachable
 13: Pattern Match
-18: Match case Unreachable
 20: Pattern Match
+21: Match case Unreachable
diff --git a/tests/patmat/null.scala b/tests/patmat/null.scala
index b918109c0cc5..9cff29a5c4e8 100644
--- a/tests/patmat/null.scala
+++ b/tests/patmat/null.scala
@@ -18,5 +18,6 @@ class Test {
     case Some(null)     =>
     case None           =>
     case y              =>
+    case _              =>
   }
 }
\ No newline at end of file

From bb63e31a8384e6e3127ee679ea0033e8437ef9ce Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Wed, 13 Nov 2024 15:24:57 +0100
Subject: [PATCH 144/306] Rename `InlineCopier` to `ConservativeTreeCopier`,
 use it in `TypeMap`s

---
 compiler/src/dotty/tools/dotc/ast/tpd.scala   |  8 +++++
 .../src/dotty/tools/dotc/core/Types.scala     |  9 +++++-
 .../dotty/tools/dotc/inlines/Inliner.scala    | 17 +++++------
 tests/pos/annot-17242.scala                   |  5 ++++
 tests/pos/dependent-annot2.scala              | 30 +++++++++++++++++++
 5 files changed, 58 insertions(+), 11 deletions(-)
 create mode 100644 tests/pos/annot-17242.scala
 create mode 100644 tests/pos/dependent-annot2.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 3777969b1076..55021bf50ace 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -827,6 +827,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       Closure(tree: Tree)(env, meth, tpt)
   }
 
+  // This is a more fault-tolerant copier that does not cause errors when
+  // function types in applications are undefined.
+  // This was called `Inliner.InlineCopier` before 3.6.3.
+  class ConservativeTreeCopier() 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)
+
   override def skipTransform(tree: Tree)(using Context): Boolean = tree.tpe.isError
 
   implicit class TreeOps[ThisTree <: tpd.Tree](private val tree: ThisTree) extends AnyVal {
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index ca9d73df03aa..31e11487ae38 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -6291,7 +6291,14 @@ object Types extends TypeUtils {
       }
     }
 
-    private def treeTypeMap = new TreeTypeMap(typeMap = this)
+    private def treeTypeMap = new TreeTypeMap(
+      typeMap = this,
+      // Using `ConservativeTreeCopier` is needed when copying dependent annoted
+      // types, where we can refer to a previous parameter represented as
+      // `TermParamRef` that has no underlying type yet.
+      // See tests/pos/annot-17242.scala.
+      cpy = ConservativeTreeCopier()
+    )
 
     def mapOver(syms: List[Symbol]): List[Symbol] = mapSymbols(syms, treeTypeMap)
 
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index 103f3aac7630..db041b7e8591 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -96,15 +96,6 @@ object Inliner:
     }
   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
@@ -116,7 +107,13 @@ object Inliner:
       substFrom: List[Symbol],
       substTo: List[Symbol])(using Context)
     extends TreeTypeMap(
-      typeMap, treeMap, oldOwners, newOwners, substFrom, substTo, InlineCopier()):
+      typeMap, treeMap, oldOwners, newOwners, substFrom, substTo,
+      // It is necessary to use the `ConservativeTreeCopier` 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.
+      ConservativeTreeCopier()
+    ):
 
     override def copy(
         typeMap: Type => Type,
diff --git a/tests/pos/annot-17242.scala b/tests/pos/annot-17242.scala
new file mode 100644
index 000000000000..a8fcc9dbe15f
--- /dev/null
+++ b/tests/pos/annot-17242.scala
@@ -0,0 +1,5 @@
+// See also tests/pos/annot-21595.scala
+
+class local(predicate: Int) extends annotation.StaticAnnotation
+
+def failing1(x: Int, z: Int @local(x + x)) = ()
diff --git a/tests/pos/dependent-annot2.scala b/tests/pos/dependent-annot2.scala
new file mode 100644
index 000000000000..9bfa8b594c2b
--- /dev/null
+++ b/tests/pos/dependent-annot2.scala
@@ -0,0 +1,30 @@
+class dummy(b: Any) extends annotation.StaticAnnotation
+
+class X:
+  def foo() = 1
+  def bar() = 2
+  def eq(x: X) = true
+  def id(): this.type = this
+
+class Y extends X:
+  override def bar() = 2
+  override def eq(x: X) = true
+
+def f(x: Int) = x
+def g(x: String) = x
+def g(x: Int) = x
+
+object AnnotationTests:
+  def foo1(elem: Int, bla: Int @dummy(Array(elem))) = bla
+  def foo2(elem: X, bla: Int @dummy(elem.foo())) = bla
+  def foo3(elem: Y, bla: Int @dummy(elem.foo())) = bla
+  def foo4(elem: X, bla: Int @dummy(elem.bar())) = bla
+  def foo5(elem: Y, bla: Int @dummy(elem.bar())) = bla
+  def foo6(elem: X, bla: Int @dummy(elem.eq(X()))) = bla
+  def foo7(elem: Y, bla: Int @dummy(elem.eq(Y()))) = bla
+  def foo8(elem: X, bla: Int @dummy(elem.id().foo())) = bla
+  def foo9(elem: Y, bla: Int @dummy(elem.id().foo())) = bla
+  def foo10(elem: Int, bla: Int @dummy(f(elem))) = bla
+  def foo11(elem: Int, bla: Int @dummy(g(elem))) = bla
+  def foo12(elem: Int, bla: Int @dummy(0 == elem)) = bla
+  def foo13(elem: Int, bla: Int @dummy(elem == 0)) = bla

From d2773e80cc07ba63300c91c60b7ffc755f789eaa Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Wed, 13 Nov 2024 16:03:46 +0100
Subject: [PATCH 145/306] Fix names and description for cc and setup phases

---
 compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala | 7 ++++++-
 compiler/src/dotty/tools/dotc/cc/Setup.scala         | 7 +++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 4d905a5df4ab..77d893ad49b9 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -28,6 +28,9 @@ import reporting.{trace, Message, OverrideError}
 object CheckCaptures:
   import ast.tpd.*
 
+  val name: String = "cc"
+  val description: String = "capture checking"
+
   enum EnvKind:
     case Regular        // normal case
     case NestedInOwner  // environment is a temporary one nested in the owner's environment,
@@ -192,7 +195,9 @@ class CheckCaptures extends Recheck, SymTransformer:
   import ast.tpd.*
   import CheckCaptures.*
 
-  def phaseName: String = "cc"
+  override def phaseName: String = CheckCaptures.name
+
+  override def description: String = CheckCaptures.description
 
   override def isRunnable(using Context) = super.isRunnable && Feature.ccEnabledSomewhere
 
diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index 76ae41649517..3147a0f7bd47 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -28,6 +28,9 @@ trait SetupAPI:
 
 object Setup:
 
+  val name: String = "ccSetup"
+  val description: String = "prepare compilation unit for capture checking"
+
   /** Recognizer for `res $throws exc`, returning `(res, exc)` in case of success */
   object throwsAlias:
     def unapply(tp: Type)(using Context): Option[(Type, Type)] = tp match
@@ -53,6 +56,10 @@ import Setup.*
 class Setup extends PreRecheck, SymTransformer, SetupAPI:
   thisPhase =>
 
+  override def phaseName: String = Setup.name
+
+  override def description: String = Setup.description
+
   override def isRunnable(using Context) =
     super.isRunnable && Feature.ccEnabledSomewhere
 

From 8e758e0c2c94b812b1732d410f3cb4ed149044bf Mon Sep 17 00:00:00 2001
From: Jan Chyb <jan.chyb.99@gmail.com>
Date: Wed, 13 Nov 2024 17:43:50 +0100
Subject: [PATCH 146/306] Fix issue with owners of top-level symbols in cached
 quoted code being incorrect

---
 .../tools/dotc/quoted/PickledQuotes.scala     |  4 +-
 tests/pos-macros/i20471/Macro_1.scala         | 63 +++++++++++++++++++
 tests/pos-macros/i20471/Main_2.scala          |  7 +++
 3 files changed, 73 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos-macros/i20471/Macro_1.scala
 create mode 100644 tests/pos-macros/i20471/Main_2.scala

diff --git a/compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala b/compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala
index 67a354919d5b..3ee52624710e 100644
--- a/compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala
@@ -241,7 +241,9 @@ object PickledQuotes {
         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)
+            val treeCpy = TreeTypeMap(oldOwners = List(owner), newOwners = List(owner)).apply(tree)
+            // Then replace the symbol owner with the one pointed by the quote context.
+            treeCpy.changeNonLocalOwners(ctx.owner)
           case _ =>
             tree
 
diff --git a/tests/pos-macros/i20471/Macro_1.scala b/tests/pos-macros/i20471/Macro_1.scala
new file mode 100644
index 000000000000..2fd940dbc4e2
--- /dev/null
+++ b/tests/pos-macros/i20471/Macro_1.scala
@@ -0,0 +1,63 @@
+import scala.annotation.experimental
+import scala.quoted.*
+import scala.annotation.tailrec
+
+object FlatMap {
+  @experimental inline def derived[F[_]]: FlatMap[F] = MacroFlatMap.derive
+}
+trait FlatMap[F[_]]{
+  def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
+}
+
+@experimental
+object MacroFlatMap:
+
+  inline def derive[F[_]]: FlatMap[F] = ${ flatMap }
+
+  def flatMap[F[_]: Type](using Quotes): Expr[FlatMap[F]] = '{
+    new FlatMap[F]:
+      def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B] =
+        ${ deriveTailRecM('{ a }, '{ f }) }
+  }
+
+  def deriveTailRecM[F[_]: Type, A: Type, B: Type](
+      a: Expr[A],
+      f: Expr[A => F[Either[A, B]]]
+  )(using q: Quotes): Expr[F[B]] =
+    import quotes.reflect.*
+
+    val body: PartialFunction[(Symbol, TypeRepr), Term] = {
+        case (method, tpe) => {
+          given q2: Quotes = method.asQuotes
+          '{
+            def step(x: A): B = ???
+            ???
+          }.asTerm
+        }
+      }
+
+    val term = '{ $f($a) }.asTerm
+    val name = Symbol.freshName("$anon")
+    val parents = List(TypeTree.of[Object], TypeTree.of[F[B]])
+
+    extension (sym: Symbol) def overridableMembers: List[Symbol] =
+      val member1 = sym.methodMember("abstractEffect")(0)
+      val member2 = sym.methodMember("concreteEffect")(0)
+      def meth(member: Symbol) = Symbol.newMethod(sym, member.name, This(sym).tpe.memberType(member), Flags.Override, Symbol.noSymbol)
+      List(meth(member1), meth(member2))
+
+    val cls = Symbol.newClass(Symbol.spliceOwner, name, parents.map(_.tpe), _.overridableMembers, None)
+
+    def transformDef(method: DefDef)(argss: List[List[Tree]]): Option[Term] =
+      val sym = method.symbol
+      Some(body.apply((sym, method.returnTpt.tpe)))
+
+    val members = cls.declarations
+      .filterNot(_.isClassConstructor)
+      .map: sym =>
+        sym.tree match
+          case method: DefDef => DefDef(sym, transformDef(method))
+          case _ => report.errorAndAbort(s"Not supported: $sym in ${sym.owner}")
+
+    val newCls = New(TypeIdent(cls)).select(cls.primaryConstructor).appliedToNone
+    Block(ClassDef(cls, parents, members) :: Nil, newCls).asExprOf[F[B]]
diff --git a/tests/pos-macros/i20471/Main_2.scala b/tests/pos-macros/i20471/Main_2.scala
new file mode 100644
index 000000000000..bdd1cd32ea26
--- /dev/null
+++ b/tests/pos-macros/i20471/Main_2.scala
@@ -0,0 +1,7 @@
+import scala.annotation.experimental
+
+@experimental
+object autoFlatMapTests:
+  trait TestAlgebra[T] derives FlatMap:
+    def abstractEffect(a: String): T
+    def concreteEffect(a: String): T = abstractEffect(a + " concreteEffect")

From dbd49886b9c885089e54dd0e98ebeb9a32734387 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Wed, 13 Nov 2024 23:41:05 +0100
Subject: [PATCH 147/306] Fix Windows OS detection in TraceNameManglingTest
 (#21937)

Fixes #21936

[test_windows_full]
---
 .../dotty/tools/dotc/profile/TraceNameManglingTest.scala  | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/compiler/test/dotty/tools/dotc/profile/TraceNameManglingTest.scala b/compiler/test/dotty/tools/dotc/profile/TraceNameManglingTest.scala
index 977b67740f88..f1f570cc85d4 100644
--- a/compiler/test/dotty/tools/dotc/profile/TraceNameManglingTest.scala
+++ b/compiler/test/dotty/tools/dotc/profile/TraceNameManglingTest.scala
@@ -27,8 +27,9 @@ class TraceNameManglingTest extends DottyTest {
   }
 
   @Test def escapeBackslashes(): Unit = {
-    val isWindows = sys.props("os.name").toLowerCase(Locale.ROOT) == "windows"
-    val filename = if isWindows then "/.scala" else "\\.scala"
+    val isWindows = sys.props("os.name").toLowerCase(Locale.ROOT).nn.contains("windows")
+    // It is not possible to create a file with backslash in name on Windows
+    val filename = if isWindows then "test.scala" else "\\.scala"
     checkTraceEvents(
       """
       |class /\ :
@@ -46,7 +47,8 @@ class TraceNameManglingTest extends DottyTest {
         raw"setter /\\_="
       ).map(TraceEvent("typecheck", _))
         ++ Set(
-          TraceEvent("file", if isWindows then "/.scala" else "\\\\.scala")
+          // See comment aboce for Windows limitations
+          TraceEvent("file", if isWindows then filename else "\\\\.scala")
         )
     )
   }

From a76470f9f34c878e759a20a4e2c76027a1ec6c22 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Tue, 24 Sep 2024 10:18:35 +0200
Subject: [PATCH 148/306] Implement basic version of desugaring context bounds
 for poly functions

---
 .../src/dotty/tools/dotc/ast/Desugar.scala    | 27 +++++++++++++++++++
 .../dotty/tools/dotc/parsing/Parsers.scala    |  4 +--
 .../src/dotty/tools/dotc/typer/Typer.scala    |  5 ++--
 .../contextbounds-for-poly-functions.scala    | 15 +++++++++++
 4 files changed, 47 insertions(+), 4 deletions(-)
 create mode 100644 tests/pos/contextbounds-for-poly-functions.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index e66c71731b4f..901fbd1bb601 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1221,6 +1221,33 @@ object desugar {
       case _ => body
     cpy.PolyFunction(tree)(tree.targs, stripped(tree.body)).asInstanceOf[PolyFunction]
 
+  /** Desugar [T_1 : B_1, ..., T_N : B_N] => (P_1, ..., P_M) => R
+   *  Into    [T_1, ..., T_N] => (P_1, ..., P_M) => (B_1, ..., B_N) ?=> R
+   */
+  def expandPolyFunctionContextBounds(tree: PolyFunction)(using Context): PolyFunction =
+    val PolyFunction(tparams: List[untpd.TypeDef] @unchecked, fun @ Function(vparamTypes, res)) = tree: @unchecked
+    val newTParams = tparams.map {
+      case td @ TypeDef(name, cb @ ContextBounds(bounds, ctxBounds)) =>
+        TypeDef(name, ContextBounds(bounds, List.empty))
+    }
+    var idx = -1
+    val collecedContextBounds = tparams.collect {
+      case td @ TypeDef(name, cb @ ContextBounds(bounds, ctxBounds)) if ctxBounds.nonEmpty =>
+        // TOOD(kπ) Should we handle non empty normal bounds here?
+        name -> ctxBounds
+    }.flatMap { case (name, ctxBounds) =>
+      ctxBounds.map { ctxBound =>
+        idx = idx + 1
+        makeSyntheticParameter(idx, ctxBound).withAddedFlags(Given)
+      }
+    }
+    val contextFunctionResult =
+      if collecedContextBounds.isEmpty then
+        fun
+      else
+        Function(vparamTypes, Function(collecedContextBounds, res)).withSpan(fun.span)
+    PolyFunction(newTParams, contextFunctionResult).withSpan(tree.span)
+
   /** 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 }
    */
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 47391a4114cf..7a5facf38b67 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -68,7 +68,7 @@ object Parsers {
     def acceptsVariance =
       this == Class || this == CaseClass || this == Hk
     def acceptsCtxBounds =
-      !(this == Type || this == Hk)
+      !(this == Hk)
     def acceptsWildcard =
       this == Type || this == Hk
 
@@ -3429,7 +3429,7 @@ object Parsers {
      *
      *  TypTypeParamClause::=  ‘[’ TypTypeParam {‘,’ TypTypeParam} ‘]’
      *  TypTypeParam      ::=  {Annotation}
-     *                         (id | ‘_’) [HkTypeParamClause] TypeBounds
+     *                         (id | ‘_’) [HkTypeParamClause] TypeAndCtxBounds
      *
      *  HkTypeParamClause ::=  ‘[’ HkTypeParam {‘,’ HkTypeParam} ‘]’
      *  HkTypeParam       ::=  {Annotation} [‘+’ | ‘-’]
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 817e7baf1c8c..a669d555617d 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1919,8 +1919,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
   def typedPolyFunction(tree: untpd.PolyFunction, pt: Type)(using Context): Tree =
     val tree1 = desugar.normalizePolyFunction(tree)
-    if (ctx.mode is Mode.Type) typed(desugar.makePolyFunctionType(tree1), pt)
-    else typedPolyFunctionValue(tree1, pt)
+    val tree2 = desugar.expandPolyFunctionContextBounds(tree1)
+    if (ctx.mode is Mode.Type) typed(desugar.makePolyFunctionType(tree2), pt)
+    else typedPolyFunctionValue(tree2, pt)
 
   def typedPolyFunctionValue(tree: untpd.PolyFunction, pt: Type)(using Context): Tree =
     val untpd.PolyFunction(tparams: List[untpd.TypeDef] @unchecked, fun) = tree: @unchecked
diff --git a/tests/pos/contextbounds-for-poly-functions.scala b/tests/pos/contextbounds-for-poly-functions.scala
new file mode 100644
index 000000000000..66c177cf6c89
--- /dev/null
+++ b/tests/pos/contextbounds-for-poly-functions.scala
@@ -0,0 +1,15 @@
+import scala.language.experimental.modularity
+import scala.language.future
+
+
+trait Ord[X]:
+  def compare(x: X, y: X): Int
+
+val less1 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
+
+// type Comparer = [X: Ord] => (x: X, y: X) => Boolean
+// val less2: Comparer = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
+
+// type Cmp[X] = (x: X, y: X) => Boolean
+// type Comparer2 = [X: Ord] => Cmp[X]
+// val less3: Comparer2 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0

From 8dc68c3303c70b8fbb8fbea2a127bd11f5667507 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Tue, 24 Sep 2024 10:27:47 +0200
Subject: [PATCH 149/306] Handle named context bounds in poly function context
 bound desugaring

---
 compiler/src/dotty/tools/dotc/ast/Desugar.scala  | 8 ++++++--
 tests/pos/contextbounds-for-poly-functions.scala | 6 ++++--
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 901fbd1bb601..91adf3c97733 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1230,7 +1230,7 @@ object desugar {
       case td @ TypeDef(name, cb @ ContextBounds(bounds, ctxBounds)) =>
         TypeDef(name, ContextBounds(bounds, List.empty))
     }
-    var idx = -1
+    var idx = 0
     val collecedContextBounds = tparams.collect {
       case td @ TypeDef(name, cb @ ContextBounds(bounds, ctxBounds)) if ctxBounds.nonEmpty =>
         // TOOD(kπ) Should we handle non empty normal bounds here?
@@ -1238,7 +1238,11 @@ object desugar {
     }.flatMap { case (name, ctxBounds) =>
       ctxBounds.map { ctxBound =>
         idx = idx + 1
-        makeSyntheticParameter(idx, ctxBound).withAddedFlags(Given)
+        ctxBound match
+          case ContextBoundTypeTree(_, _, ownName) =>
+            ValDef(ownName, ctxBound, EmptyTree).withFlags(TermParam | Given)
+          case _ =>
+            makeSyntheticParameter(idx, ctxBound).withAddedFlags(Given)
       }
     }
     val contextFunctionResult =
diff --git a/tests/pos/contextbounds-for-poly-functions.scala b/tests/pos/contextbounds-for-poly-functions.scala
index 66c177cf6c89..00feedd66d71 100644
--- a/tests/pos/contextbounds-for-poly-functions.scala
+++ b/tests/pos/contextbounds-for-poly-functions.scala
@@ -7,9 +7,11 @@ trait Ord[X]:
 
 val less1 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
+val less2 = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
+
 // type Comparer = [X: Ord] => (x: X, y: X) => Boolean
-// val less2: Comparer = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
+// val less3: Comparer = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
 
 // type Cmp[X] = (x: X, y: X) => Boolean
 // type Comparer2 = [X: Ord] => Cmp[X]
-// val less3: Comparer2 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
+// val less4: Comparer2 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0

From 3ac5cec843d2f276cb851b67ea7d46871853bdde Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Tue, 24 Sep 2024 16:12:28 +0200
Subject: [PATCH 150/306] Correctly-ish desugar poly function context bounds in
 function types

---
 .../src/dotty/tools/dotc/ast/Desugar.scala    | 23 +++++++++++--------
 .../src/dotty/tools/dotc/typer/Typer.scala    | 19 ++++++++-------
 .../contextbounds-for-poly-functions.scala    |  9 ++++----
 3 files changed, 30 insertions(+), 21 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 91adf3c97733..5db72d2f5a09 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1226,31 +1226,36 @@ object desugar {
    */
   def expandPolyFunctionContextBounds(tree: PolyFunction)(using Context): PolyFunction =
     val PolyFunction(tparams: List[untpd.TypeDef] @unchecked, fun @ Function(vparamTypes, res)) = tree: @unchecked
-    val newTParams = tparams.map {
+    val newTParams = tparams.mapConserve {
       case td @ TypeDef(name, cb @ ContextBounds(bounds, ctxBounds)) =>
         TypeDef(name, ContextBounds(bounds, List.empty))
+      case t => t
     }
     var idx = 0
-    val collecedContextBounds = tparams.collect {
+    val collectedContextBounds = tparams.collect {
       case td @ TypeDef(name, cb @ ContextBounds(bounds, ctxBounds)) if ctxBounds.nonEmpty =>
-        // TOOD(kπ) Should we handle non empty normal bounds here?
         name -> ctxBounds
     }.flatMap { case (name, ctxBounds) =>
       ctxBounds.map { ctxBound =>
         idx = idx + 1
         ctxBound match
-          case ContextBoundTypeTree(_, _, ownName) =>
-            ValDef(ownName, ctxBound, EmptyTree).withFlags(TermParam | Given)
+          case ctxBound @ ContextBoundTypeTree(tycon, paramName, ownName) =>
+            if tree.isTerm then
+              ValDef(ownName, ctxBound, EmptyTree).withFlags(TermParam | Given)
+            else
+              ContextBoundTypeTree(tycon, paramName, EmptyTermName) // this has to be handled in Typer#typedFunctionType
           case _ =>
             makeSyntheticParameter(idx, ctxBound).withAddedFlags(Given)
       }
     }
     val contextFunctionResult =
-      if collecedContextBounds.isEmpty then
-        fun
+      if collectedContextBounds.isEmpty then fun
       else
-        Function(vparamTypes, Function(collecedContextBounds, res)).withSpan(fun.span)
-    PolyFunction(newTParams, contextFunctionResult).withSpan(tree.span)
+        val mods = EmptyModifiers.withFlags(Given)
+        val erasedParams = collectedContextBounds.map(_ => false)
+        Function(vparamTypes, FunctionWithMods(collectedContextBounds, res, mods, erasedParams)).withSpan(fun.span)
+    if collectedContextBounds.isEmpty then tree
+    else PolyFunction(newTParams, contextFunctionResult).withSpan(tree.span)
 
   /** 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 }
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index a669d555617d..4dfd2c05c808 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -40,7 +40,7 @@ import annotation.tailrec
 import Implicits.*
 import util.Stats.record
 import config.Printers.{gadts, typr}
-import config.Feature, Feature.{migrateTo3, modularity, sourceVersion, warnOnMigration}
+import config.Feature, Feature.{migrateTo3, sourceVersion, warnOnMigration}
 import config.SourceVersion.*
 import rewrites.Rewrites, Rewrites.patch
 import staging.StagingLevel
@@ -1145,7 +1145,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         if templ1.parents.isEmpty
             && isFullyDefined(pt, ForceDegree.flipBottom)
             && isSkolemFree(pt)
-            && isEligible(pt.underlyingClassRef(refinementOK = Feature.enabled(modularity)))
+            && isEligible(pt.underlyingClassRef(refinementOK = Feature.enabled(Feature.modularity)))
         then
           templ1 = cpy.Template(templ)(parents = untpd.TypeTree(pt) :: Nil)
         for case parent: RefTree <- templ1.parents do
@@ -1720,7 +1720,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           typedFunctionType(desugar.makeFunctionWithValDefs(tree, pt), pt)
         else
           val funSym = defn.FunctionSymbol(numArgs, isContextual, isImpure)
-          val result = typed(cpy.AppliedTypeTree(tree)(untpd.TypeTree(funSym.typeRef), args :+ body), pt)
+          val args1 = args.mapConserve {
+            case cb: untpd.ContextBoundTypeTree => typed(cb)
+            case t => t
+          }
+          val result = typed(cpy.AppliedTypeTree(tree)(untpd.TypeTree(funSym.typeRef), args1 :+ body), pt)
           // if there are any erased classes, we need to re-do the typecheck.
           result match
             case r: AppliedTypeTree if r.args.exists(_.tpe.isErasedClass) =>
@@ -2451,12 +2455,12 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     if tycon.tpe.typeParams.nonEmpty then
       val tycon0 = tycon.withType(tycon.tpe.etaCollapse)
       typed(untpd.AppliedTypeTree(spliced(tycon0), tparam :: Nil))
-    else if Feature.enabled(modularity) && tycon.tpe.member(tpnme.Self).symbol.isAbstractOrParamType then
+    else if Feature.enabled(Feature.modularity) && tycon.tpe.member(tpnme.Self).symbol.isAbstractOrParamType then
       val tparamSplice = untpd.TypedSplice(typedExpr(tparam))
       typed(untpd.RefinedTypeTree(spliced(tycon), List(untpd.TypeDef(tpnme.Self, tparamSplice))))
     else
       def selfNote =
-        if Feature.enabled(modularity) then
+        if Feature.enabled(Feature.modularity) then
           " and\ndoes not have an abstract type member named `Self` either"
         else ""
       errorTree(tree,
@@ -2475,7 +2479,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val TypeDef(_, impl: Template) = typed(refineClsDef): @unchecked
     val refinements1 = impl.body
     val seen = mutable.Set[Symbol]()
-    for (refinement <- refinements1) { // TODO: get clarity whether we want to enforce these conditions
+    for refinement <- refinements1 do // TODO: get clarity whether we want to enforce these conditions
       typr.println(s"adding refinement $refinement")
       checkRefinementNonCyclic(refinement, refineCls, seen)
       val rsym = refinement.symbol
@@ -2489,7 +2493,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       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)
   }
 
@@ -4706,7 +4709,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           cpy.Ident(qual)(qual.symbol.name.sourceModuleName.toTypeName)
         case _ =>
           errorTree(tree, em"cannot convert from $tree to an instance creation expression")
-      val tycon = ctorResultType.underlyingClassRef(refinementOK = Feature.enabled(modularity))
+      val tycon = ctorResultType.underlyingClassRef(refinementOK = Feature.enabled(Feature.modularity))
       typed(
         untpd.Select(
           untpd.New(untpd.TypedSplice(tpt.withType(tycon))),
diff --git a/tests/pos/contextbounds-for-poly-functions.scala b/tests/pos/contextbounds-for-poly-functions.scala
index 00feedd66d71..90bd01ce6b6d 100644
--- a/tests/pos/contextbounds-for-poly-functions.scala
+++ b/tests/pos/contextbounds-for-poly-functions.scala
@@ -5,12 +5,13 @@ import scala.language.future
 trait Ord[X]:
   def compare(x: X, y: X): Int
 
-val less1 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
+// val less1 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
-val less2 = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
+// val less2 = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
 
-// type Comparer = [X: Ord] => (x: X, y: X) => Boolean
-// val less3: Comparer = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
+type ComparerRef = [X] => (x: X, y: X) => Ord[X] ?=> Boolean
+type Comparer = [X: Ord] => (x: X, y: X) => Boolean
+val less3: Comparer = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
 
 // type Cmp[X] = (x: X, y: X) => Boolean
 // type Comparer2 = [X: Ord] => Cmp[X]

From 408aa74c158290a69f3411f12c719daaa45e8021 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Tue, 24 Sep 2024 16:17:26 +0200
Subject: [PATCH 151/306] Fix pickling issue

---
 compiler/src/dotty/tools/dotc/ast/Desugar.scala  | 2 +-
 tests/pos/contextbounds-for-poly-functions.scala | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 5db72d2f5a09..12c237701d62 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1228,7 +1228,7 @@ object desugar {
     val PolyFunction(tparams: List[untpd.TypeDef] @unchecked, fun @ Function(vparamTypes, res)) = tree: @unchecked
     val newTParams = tparams.mapConserve {
       case td @ TypeDef(name, cb @ ContextBounds(bounds, ctxBounds)) =>
-        TypeDef(name, ContextBounds(bounds, List.empty))
+        cpy.TypeDef(td)(name, bounds)
       case t => t
     }
     var idx = 0
diff --git a/tests/pos/contextbounds-for-poly-functions.scala b/tests/pos/contextbounds-for-poly-functions.scala
index 90bd01ce6b6d..6a3ec9935a65 100644
--- a/tests/pos/contextbounds-for-poly-functions.scala
+++ b/tests/pos/contextbounds-for-poly-functions.scala
@@ -5,10 +5,11 @@ import scala.language.future
 trait Ord[X]:
   def compare(x: X, y: X): Int
 
-// val less1 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
+val less1 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
-// val less2 = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
+val less2 = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
 
+type CtxFunctionRef = Ord[Int] ?=> Boolean
 type ComparerRef = [X] => (x: X, y: X) => Ord[X] ?=> Boolean
 type Comparer = [X: Ord] => (x: X, y: X) => Boolean
 val less3: Comparer = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0

From 134c0150617a091d5ea482374c3a42e2572e78ad Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Tue, 24 Sep 2024 16:47:13 +0200
Subject: [PATCH 152/306] Hide context bounds expansion for poly functions
 under modularity feature

---
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala | 6 ++++--
 compiler/src/dotty/tools/dotc/typer/Typer.scala     | 3 ++-
 tests/pos/contextbounds-for-poly-functions.scala    | 1 -
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 7a5facf38b67..e54caff9f47d 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -68,7 +68,7 @@ object Parsers {
     def acceptsVariance =
       this == Class || this == CaseClass || this == Hk
     def acceptsCtxBounds =
-      !(this == Hk)
+      !(this == Type || this == Hk)
     def acceptsWildcard =
       this == Type || this == Hk
 
@@ -3460,7 +3460,9 @@ object Parsers {
             else ident().toTypeName
           val hkparams = typeParamClauseOpt(ParamOwner.Hk)
           val bounds =
-            if paramOwner.acceptsCtxBounds then typeAndCtxBounds(name) else typeBounds()
+            if paramOwner.acceptsCtxBounds then typeAndCtxBounds(name)
+            else if in.featureEnabled(Feature.modularity) && paramOwner == ParamOwner.Type then typeAndCtxBounds(name)
+            else typeBounds()
           TypeDef(name, lambdaAbstract(hkparams, bounds)).withMods(mods)
         }
       }
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 4dfd2c05c808..4a656c15a9ea 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1923,7 +1923,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
   def typedPolyFunction(tree: untpd.PolyFunction, pt: Type)(using Context): Tree =
     val tree1 = desugar.normalizePolyFunction(tree)
-    val tree2 = desugar.expandPolyFunctionContextBounds(tree1)
+    val tree2 = if Feature.enabled(Feature.modularity) then desugar.expandPolyFunctionContextBounds(tree1)
+                else tree1
     if (ctx.mode is Mode.Type) typed(desugar.makePolyFunctionType(tree2), pt)
     else typedPolyFunctionValue(tree2, pt)
 
diff --git a/tests/pos/contextbounds-for-poly-functions.scala b/tests/pos/contextbounds-for-poly-functions.scala
index 6a3ec9935a65..c293fd0d9780 100644
--- a/tests/pos/contextbounds-for-poly-functions.scala
+++ b/tests/pos/contextbounds-for-poly-functions.scala
@@ -1,7 +1,6 @@
 import scala.language.experimental.modularity
 import scala.language.future
 
-
 trait Ord[X]:
   def compare(x: X, y: X): Int
 

From 309034e5579dd5dcf2667d5cd096c1067681b724 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Wed, 25 Sep 2024 09:43:30 +0200
Subject: [PATCH 153/306] Small cleanup

---
 compiler/src/dotty/tools/dotc/ast/Desugar.scala  | 14 +++++---------
 tests/pos/contextbounds-for-poly-functions.scala |  2 ++
 2 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 12c237701d62..d37af4aaedae 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1237,15 +1237,11 @@ object desugar {
         name -> ctxBounds
     }.flatMap { case (name, ctxBounds) =>
       ctxBounds.map { ctxBound =>
-        idx = idx + 1
-        ctxBound match
-          case ctxBound @ ContextBoundTypeTree(tycon, paramName, ownName) =>
-            if tree.isTerm then
-              ValDef(ownName, ctxBound, EmptyTree).withFlags(TermParam | Given)
-            else
-              ContextBoundTypeTree(tycon, paramName, EmptyTermName) // this has to be handled in Typer#typedFunctionType
-          case _ =>
-            makeSyntheticParameter(idx, ctxBound).withAddedFlags(Given)
+        val ContextBoundTypeTree(tycon, paramName, ownName) = ctxBound: @unchecked
+        if tree.isTerm then
+          ValDef(ownName, ctxBound, EmptyTree).withFlags(TermParam | Given)
+        else
+          ContextBoundTypeTree(tycon, paramName, EmptyTermName) // this has to be handled in Typer#typedFunctionType
       }
     }
     val contextFunctionResult =
diff --git a/tests/pos/contextbounds-for-poly-functions.scala b/tests/pos/contextbounds-for-poly-functions.scala
index c293fd0d9780..7da7405c9225 100644
--- a/tests/pos/contextbounds-for-poly-functions.scala
+++ b/tests/pos/contextbounds-for-poly-functions.scala
@@ -16,3 +16,5 @@ val less3: Comparer = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
 // type Cmp[X] = (x: X, y: X) => Boolean
 // type Comparer2 = [X: Ord] => Cmp[X]
 // val less4: Comparer2 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
+
+val less5 = [X: [X] =>> Ord[X]] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
\ No newline at end of file

From 64bd03eff0d4a901de85b563e681e1ffc5d8eb24 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Wed, 25 Sep 2024 09:49:23 +0200
Subject: [PATCH 154/306] Add more test cases

---
 tests/pos/contextbounds-for-poly-functions.scala | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/tests/pos/contextbounds-for-poly-functions.scala b/tests/pos/contextbounds-for-poly-functions.scala
index 7da7405c9225..7db41628e57d 100644
--- a/tests/pos/contextbounds-for-poly-functions.scala
+++ b/tests/pos/contextbounds-for-poly-functions.scala
@@ -4,6 +4,9 @@ import scala.language.future
 trait Ord[X]:
   def compare(x: X, y: X): Int
 
+trait Show[X]:
+  def show(x: X): String
+
 val less1 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
 val less2 = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
@@ -17,4 +20,12 @@ val less3: Comparer = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
 // type Comparer2 = [X: Ord] => Cmp[X]
 // val less4: Comparer2 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
-val less5 = [X: [X] =>> Ord[X]] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
\ No newline at end of file
+val less5 = [X: [X] =>> Ord[X]] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
+
+val less6 = [X: {Ord, Show}] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
+
+val less7 = [X: {Ord as ord, Show}] => (x: X, y: X) => ord.compare(x, y) < 0
+
+val less8 = [X: {Ord, Show as show}] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
+
+val less9 = [X: {Ord as ord, Show as show}] => (x: X, y: X) => ord.compare(x, y) < 0

From 5196efde72f40ebca4f516cf4febace2ce9cda15 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Wed, 2 Oct 2024 17:23:15 +0200
Subject: [PATCH 155/306] Change the implementation of context bound expansion
 for poly functions to reuse some of the existing context bound expansion

---
 .../src/dotty/tools/dotc/ast/Desugar.scala    | 58 ++++++++-----------
 .../src/dotty/tools/dotc/typer/Typer.scala    | 34 ++++++-----
 .../contextbounds-for-poly-functions.scala    | 27 +++++++++
 3 files changed, 68 insertions(+), 51 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index d37af4aaedae..488755f81848 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -52,6 +52,11 @@ object desugar {
    */
   val ContextBoundParam: Property.Key[Unit] = Property.StickyKey()
 
+  /** An attachment key to indicate that a DefDef is a poly function apply
+   * method definition.
+   */
+  val PolyFunctionApply: Property.Key[Unit] = Property.StickyKey()
+
   /** What static check should be applied to a Match? */
   enum MatchCheck {
     case None, Exhaustive, IrrefutablePatDef, IrrefutableGenFrom
@@ -337,7 +342,8 @@ object desugar {
           cpy.DefDef(meth)(
             name = normalizeName(meth, tpt).asTermName,
             paramss = paramssNoContextBounds),
-          evidenceParamBuf.toList)
+          evidenceParamBuf.toList
+        )
   end elimContextBounds
 
   def addDefaultGetters(meth: DefDef)(using Context): Tree =
@@ -508,7 +514,19 @@ object desugar {
       case Nil =>
         params :: Nil
 
-    cpy.DefDef(meth)(paramss = recur(meth.paramss))
+    if meth.hasAttachment(PolyFunctionApply) then
+      meth.removeAttachment(PolyFunctionApply)
+      val paramTpts = params.map(_.tpt)
+      val paramNames = params.map(_.name)
+      val paramsErased = params.map(_.mods.flags.is(Erased))
+      if ctx.mode.is(Mode.Type) then
+        val ctxFunction = makeContextualFunction(paramTpts, paramNames, meth.tpt, paramsErased)
+        cpy.DefDef(meth)(tpt = ctxFunction)
+      else
+        val ctxFunction = makeContextualFunction(paramTpts, paramNames, meth.rhs, paramsErased)
+        cpy.DefDef(meth)(rhs = ctxFunction)
+    else
+      cpy.DefDef(meth)(paramss = recur(meth.paramss))
   end addEvidenceParams
 
   /** The parameters generated from the contextual bounds of `meth`, as generated by `desugar.defDef` */
@@ -1221,38 +1239,6 @@ object desugar {
       case _ => body
     cpy.PolyFunction(tree)(tree.targs, stripped(tree.body)).asInstanceOf[PolyFunction]
 
-  /** Desugar [T_1 : B_1, ..., T_N : B_N] => (P_1, ..., P_M) => R
-   *  Into    [T_1, ..., T_N] => (P_1, ..., P_M) => (B_1, ..., B_N) ?=> R
-   */
-  def expandPolyFunctionContextBounds(tree: PolyFunction)(using Context): PolyFunction =
-    val PolyFunction(tparams: List[untpd.TypeDef] @unchecked, fun @ Function(vparamTypes, res)) = tree: @unchecked
-    val newTParams = tparams.mapConserve {
-      case td @ TypeDef(name, cb @ ContextBounds(bounds, ctxBounds)) =>
-        cpy.TypeDef(td)(name, bounds)
-      case t => t
-    }
-    var idx = 0
-    val collectedContextBounds = tparams.collect {
-      case td @ TypeDef(name, cb @ ContextBounds(bounds, ctxBounds)) if ctxBounds.nonEmpty =>
-        name -> ctxBounds
-    }.flatMap { case (name, ctxBounds) =>
-      ctxBounds.map { ctxBound =>
-        val ContextBoundTypeTree(tycon, paramName, ownName) = ctxBound: @unchecked
-        if tree.isTerm then
-          ValDef(ownName, ctxBound, EmptyTree).withFlags(TermParam | Given)
-        else
-          ContextBoundTypeTree(tycon, paramName, EmptyTermName) // this has to be handled in Typer#typedFunctionType
-      }
-    }
-    val contextFunctionResult =
-      if collectedContextBounds.isEmpty then fun
-      else
-        val mods = EmptyModifiers.withFlags(Given)
-        val erasedParams = collectedContextBounds.map(_ => false)
-        Function(vparamTypes, FunctionWithMods(collectedContextBounds, res, mods, erasedParams)).withSpan(fun.span)
-    if collectedContextBounds.isEmpty then tree
-    else PolyFunction(newTParams, contextFunctionResult).withSpan(tree.span)
-
   /** 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 }
    */
@@ -1275,7 +1261,9 @@ object desugar {
     }.toList
 
     RefinedTypeTree(ref(defn.PolyFunctionType), List(
-       DefDef(nme.apply, tparams :: vparams :: Nil, res, EmptyTree).withFlags(Synthetic)
+      DefDef(nme.apply, tparams :: vparams :: Nil, res, EmptyTree)
+        .withFlags(Synthetic)
+        .withAttachment(PolyFunctionApply, ())
     )).withSpan(tree.span)
   end makePolyFunctionType
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 4a656c15a9ea..00f22c874f7c 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -40,7 +40,7 @@ import annotation.tailrec
 import Implicits.*
 import util.Stats.record
 import config.Printers.{gadts, typr}
-import config.Feature, Feature.{migrateTo3, sourceVersion, warnOnMigration}
+import config.Feature, Feature.{migrateTo3, modularity, sourceVersion, warnOnMigration}
 import config.SourceVersion.*
 import rewrites.Rewrites, Rewrites.patch
 import staging.StagingLevel
@@ -53,6 +53,7 @@ import config.MigrationVersion
 import transform.CheckUnused.OriginalName
 
 import scala.annotation.constructorOnly
+import dotty.tools.dotc.ast.desugar.PolyFunctionApply
 
 object Typer {
 
@@ -1145,7 +1146,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         if templ1.parents.isEmpty
             && isFullyDefined(pt, ForceDegree.flipBottom)
             && isSkolemFree(pt)
-            && isEligible(pt.underlyingClassRef(refinementOK = Feature.enabled(Feature.modularity)))
+            && isEligible(pt.underlyingClassRef(refinementOK = Feature.enabled(modularity)))
         then
           templ1 = cpy.Template(templ)(parents = untpd.TypeTree(pt) :: Nil)
         for case parent: RefTree <- templ1.parents do
@@ -1720,11 +1721,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           typedFunctionType(desugar.makeFunctionWithValDefs(tree, pt), pt)
         else
           val funSym = defn.FunctionSymbol(numArgs, isContextual, isImpure)
-          val args1 = args.mapConserve {
-            case cb: untpd.ContextBoundTypeTree => typed(cb)
-            case t => t
-          }
-          val result = typed(cpy.AppliedTypeTree(tree)(untpd.TypeTree(funSym.typeRef), args1 :+ body), pt)
+          // val args1 = args.mapConserve {
+          //   case cb: untpd.ContextBoundTypeTree => typed(cb)
+          //   case t => t
+          // }
+          val result = typed(cpy.AppliedTypeTree(tree)(untpd.TypeTree(funSym.typeRef), args :+ body), pt)
           // if there are any erased classes, we need to re-do the typecheck.
           result match
             case r: AppliedTypeTree if r.args.exists(_.tpe.isErasedClass) =>
@@ -1923,10 +1924,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
   def typedPolyFunction(tree: untpd.PolyFunction, pt: Type)(using Context): Tree =
     val tree1 = desugar.normalizePolyFunction(tree)
-    val tree2 = if Feature.enabled(Feature.modularity) then desugar.expandPolyFunctionContextBounds(tree1)
-                else tree1
-    if (ctx.mode is Mode.Type) typed(desugar.makePolyFunctionType(tree2), pt)
-    else typedPolyFunctionValue(tree2, pt)
+    if (ctx.mode is Mode.Type) typed(desugar.makePolyFunctionType(tree1), pt)
+    else typedPolyFunctionValue(tree1, pt)
 
   def typedPolyFunctionValue(tree: untpd.PolyFunction, pt: Type)(using Context): Tree =
     val untpd.PolyFunction(tparams: List[untpd.TypeDef] @unchecked, fun) = tree: @unchecked
@@ -1951,7 +1950,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           val resultTpt =
             untpd.InLambdaTypeTree(isResult = true, (tsyms, vsyms) =>
               mt.resultType.substParams(mt, vsyms.map(_.termRef)).substParams(poly, tsyms.map(_.typeRef)))
-          val desugared = desugar.makeClosure(tparams, inferredVParams, body, resultTpt, tree.span)
+          val desugared @ Block(List(defdef), _) = desugar.makeClosure(tparams, inferredVParams, body, resultTpt, tree.span)
+          defdef.putAttachment(PolyFunctionApply, ())
           typed(desugared, pt)
         else
           val msg =
@@ -1959,7 +1959,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                  |Expected type should be a polymorphic function with the same number of type and value parameters."""
           errorTree(EmptyTree, msg, tree.srcPos)
       case _ =>
-        val desugared = desugar.makeClosure(tparams, vparams, body, untpd.TypeTree(), tree.span)
+        val desugared @ Block(List(defdef), _) = desugar.makeClosure(tparams, vparams, body, untpd.TypeTree(), tree.span)
+        defdef.putAttachment(PolyFunctionApply, ())
         typed(desugared, pt)
   end typedPolyFunctionValue
 
@@ -2456,12 +2457,12 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     if tycon.tpe.typeParams.nonEmpty then
       val tycon0 = tycon.withType(tycon.tpe.etaCollapse)
       typed(untpd.AppliedTypeTree(spliced(tycon0), tparam :: Nil))
-    else if Feature.enabled(Feature.modularity) && tycon.tpe.member(tpnme.Self).symbol.isAbstractOrParamType then
+    else if Feature.enabled(modularity) && tycon.tpe.member(tpnme.Self).symbol.isAbstractOrParamType then
       val tparamSplice = untpd.TypedSplice(typedExpr(tparam))
       typed(untpd.RefinedTypeTree(spliced(tycon), List(untpd.TypeDef(tpnme.Self, tparamSplice))))
     else
       def selfNote =
-        if Feature.enabled(Feature.modularity) then
+        if Feature.enabled(modularity) then
           " and\ndoes not have an abstract type member named `Self` either"
         else ""
       errorTree(tree,
@@ -3610,6 +3611,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
   protected def makeContextualFunction(tree: untpd.Tree, pt: Type)(using Context): Tree = {
     val defn.FunctionOf(formals, _, true) = pt.dropDependentRefinement: @unchecked
+    println(i"make contextual function $tree / $pt")
     val paramNamesOrNil = pt match
       case RefinedType(_, _, rinfo: MethodType) => rinfo.paramNames
       case _ => Nil
@@ -4710,7 +4712,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           cpy.Ident(qual)(qual.symbol.name.sourceModuleName.toTypeName)
         case _ =>
           errorTree(tree, em"cannot convert from $tree to an instance creation expression")
-      val tycon = ctorResultType.underlyingClassRef(refinementOK = Feature.enabled(Feature.modularity))
+      val tycon = ctorResultType.underlyingClassRef(refinementOK = Feature.enabled(modularity))
       typed(
         untpd.Select(
           untpd.New(untpd.TypedSplice(tpt.withType(tycon))),
diff --git a/tests/pos/contextbounds-for-poly-functions.scala b/tests/pos/contextbounds-for-poly-functions.scala
index 7db41628e57d..a5a035754b08 100644
--- a/tests/pos/contextbounds-for-poly-functions.scala
+++ b/tests/pos/contextbounds-for-poly-functions.scala
@@ -7,10 +7,18 @@ trait Ord[X]:
 trait Show[X]:
   def show(x: X): String
 
+val less0: [X: Ord] => (X, X) => Boolean = ???
+
 val less1 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
+val less1_type_test: [X: Ord] => (X, X) => Boolean =
+  [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
+
 val less2 = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
 
+val less2_type_test: [X: Ord as ord] => (X, X) => Boolean =
+  [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
+
 type CtxFunctionRef = Ord[Int] ?=> Boolean
 type ComparerRef = [X] => (x: X, y: X) => Ord[X] ?=> Boolean
 type Comparer = [X: Ord] => (x: X, y: X) => Boolean
@@ -20,12 +28,31 @@ val less3: Comparer = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
 // type Comparer2 = [X: Ord] => Cmp[X]
 // val less4: Comparer2 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
+// type CmpWeak[X] = (x: X, y: X) => Boolean
+// type Comparer2Weak = [X: Ord] => (x: X) => CmpWeak[X]
+// val less4: Comparer2Weak = [X: Ord] => (x: X) => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
+
 val less5 = [X: [X] =>> Ord[X]] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
+val less5_type_test: [X: [X] =>> Ord[X]] => (X, X) => Boolean =
+  [X: [X] =>> Ord[X]] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
+
 val less6 = [X: {Ord, Show}] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
+val less6_type_test: [X: {Ord, Show}] => (X, X) => Boolean =
+  [X: {Ord, Show}] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
+
 val less7 = [X: {Ord as ord, Show}] => (x: X, y: X) => ord.compare(x, y) < 0
 
+val less7_type_test: [X: {Ord as ord, Show}] => (X, X) => Boolean =
+  [X: {Ord as ord, Show}] => (x: X, y: X) => ord.compare(x, y) < 0
+
 val less8 = [X: {Ord, Show as show}] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
+val less8_type_test: [X: {Ord, Show as show}] => (X, X) => Boolean =
+  [X: {Ord, Show as show}] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
+
 val less9 = [X: {Ord as ord, Show as show}] => (x: X, y: X) => ord.compare(x, y) < 0
+
+val less9_type_test: [X: {Ord as ord, Show as show}] => (X, X) => Boolean =
+  [X: {Ord as ord, Show as show}] => (x: X, y: X) => ord.compare(x, y) < 0

From 5f0d4a7205ce80d3576c92df1c7243e67031f430 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Thu, 3 Oct 2024 15:49:53 +0200
Subject: [PATCH 156/306] Add support for some type aliases, when expanding
 context bounds for poly functions

---
 .../src/dotty/tools/dotc/ast/Desugar.scala    | 26 ++++++---
 .../src/dotty/tools/dotc/typer/Typer.scala    | 56 ++++++++++++++-----
 .../contextbounds-for-poly-functions.scala    |  9 ++-
 3 files changed, 64 insertions(+), 27 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 488755f81848..56e519737cb1 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -55,7 +55,7 @@ object desugar {
   /** An attachment key to indicate that a DefDef is a poly function apply
    * method definition.
    */
-  val PolyFunctionApply: Property.Key[Unit] = Property.StickyKey()
+  val PolyFunctionApply: Property.Key[List[ValDef]] = Property.StickyKey()
 
   /** What static check should be applied to a Match? */
   enum MatchCheck {
@@ -514,17 +514,25 @@ object desugar {
       case Nil =>
         params :: Nil
 
+    // TODO(kπ) is this enough? SHould this be a TreeTraverse-thing?
+    def pushDownEvidenceParams(tree: Tree): Tree = tree match
+      case Function(params, body) =>
+        cpy.Function(tree)(params, pushDownEvidenceParams(body))
+      case Block(stats, expr) =>
+        cpy.Block(tree)(stats, pushDownEvidenceParams(expr))
+      case tree =>
+        val paramTpts = params.map(_.tpt)
+        val paramNames = params.map(_.name)
+        val paramsErased = params.map(_.mods.flags.is(Erased))
+        makeContextualFunction(paramTpts, paramNames, tree, paramsErased).withSpan(tree.span)
+
     if meth.hasAttachment(PolyFunctionApply) then
       meth.removeAttachment(PolyFunctionApply)
-      val paramTpts = params.map(_.tpt)
-      val paramNames = params.map(_.name)
-      val paramsErased = params.map(_.mods.flags.is(Erased))
+      // (kπ): deffer this until we can type the result?
       if ctx.mode.is(Mode.Type) then
-        val ctxFunction = makeContextualFunction(paramTpts, paramNames, meth.tpt, paramsErased)
-        cpy.DefDef(meth)(tpt = ctxFunction)
+        cpy.DefDef(meth)(tpt = meth.tpt.withAttachment(PolyFunctionApply, params))
       else
-        val ctxFunction = makeContextualFunction(paramTpts, paramNames, meth.rhs, paramsErased)
-        cpy.DefDef(meth)(rhs = ctxFunction)
+        cpy.DefDef(meth)(rhs = pushDownEvidenceParams(meth.rhs))
     else
       cpy.DefDef(meth)(paramss = recur(meth.paramss))
   end addEvidenceParams
@@ -1263,7 +1271,7 @@ object desugar {
     RefinedTypeTree(ref(defn.PolyFunctionType), List(
       DefDef(nme.apply, tparams :: vparams :: Nil, res, EmptyTree)
         .withFlags(Synthetic)
-        .withAttachment(PolyFunctionApply, ())
+        .withAttachment(PolyFunctionApply, List.empty)
     )).withSpan(tree.span)
   end makePolyFunctionType
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 00f22c874f7c..56e62bccf83b 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -53,7 +53,6 @@ import config.MigrationVersion
 import transform.CheckUnused.OriginalName
 
 import scala.annotation.constructorOnly
-import dotty.tools.dotc.ast.desugar.PolyFunctionApply
 
 object Typer {
 
@@ -1951,7 +1950,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             untpd.InLambdaTypeTree(isResult = true, (tsyms, vsyms) =>
               mt.resultType.substParams(mt, vsyms.map(_.termRef)).substParams(poly, tsyms.map(_.typeRef)))
           val desugared @ Block(List(defdef), _) = desugar.makeClosure(tparams, inferredVParams, body, resultTpt, tree.span)
-          defdef.putAttachment(PolyFunctionApply, ())
+          defdef.putAttachment(desugar.PolyFunctionApply, List.empty)
           typed(desugared, pt)
         else
           val msg =
@@ -1960,7 +1959,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           errorTree(EmptyTree, msg, tree.srcPos)
       case _ =>
         val desugared @ Block(List(defdef), _) = desugar.makeClosure(tparams, vparams, body, untpd.TypeTree(), tree.span)
-        defdef.putAttachment(PolyFunctionApply, ())
+        defdef.putAttachment(desugar.PolyFunctionApply, List.empty)
         typed(desugared, pt)
   end typedPolyFunctionValue
 
@@ -3588,30 +3587,57 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
               case xtree => typedUnnamed(xtree)
 
           val unsimplifiedType = result.tpe
-          simplify(result, pt, locked)
-          result.tpe.stripTypeVar match
+          val result1 = simplify(result, pt, locked)
+          result1.tpe.stripTypeVar match
             case e: ErrorType if !unsimplifiedType.isErroneous => errorTree(xtree, e.msg, xtree.srcPos)
-            case _ => result
+            case _ => result1
         catch case ex: TypeError =>
           handleTypeError(ex)
      }
   }
 
+  private def pushDownDeferredEvidenceParams(tpe: Type, params: List[untpd.ValDef], span: Span)(using Context): Type = tpe.dealias match {
+    case tpe: MethodType =>
+      MethodType(tpe.paramNames)(paramNames => tpe.paramInfos, _ => pushDownDeferredEvidenceParams(tpe.resultType, params, span))
+    case tpe: PolyType =>
+      PolyType(tpe.paramNames)(paramNames => tpe.paramInfos, _ => pushDownDeferredEvidenceParams(tpe.resultType, params, span))
+    case tpe: RefinedType =>
+      // TODO(kπ): Doesn't seem right, but the PolyFunction ends up being a refinement
+      RefinedType(pushDownDeferredEvidenceParams(tpe.parent, params, span), tpe.refinedName, pushDownDeferredEvidenceParams(tpe.refinedInfo, params, span))
+    case tpe @ AppliedType(tycon, args) if defn.isFunctionType(tpe) && args.size > 1 =>
+      AppliedType(tpe.tycon, args.init :+ pushDownDeferredEvidenceParams(args.last, params, span))
+    case tpe =>
+      val paramNames = params.map(_.name)
+      val paramTpts = params.map(_.tpt)
+      val paramsErased = params.map(_.mods.flags.is(Erased))
+      val ctxFunction = desugar.makeContextualFunction(paramTpts, paramNames, untpd.TypedSplice(TypeTree(tpe.dealias)), paramsErased).withSpan(span)
+      typed(ctxFunction).tpe
+  }
+
+  private def addDownDeferredEvidenceParams(tree: Tree, pt: Type)(using Context): (Tree, Type) = {
+    tree.getAttachment(desugar.PolyFunctionApply) match
+      case Some(params) if params.nonEmpty =>
+        tree.removeAttachment(desugar.PolyFunctionApply)
+        val tpe = pushDownDeferredEvidenceParams(tree.tpe, params, tree.span)
+        TypeTree(tpe).withSpan(tree.span) -> tpe
+      case _ => tree -> pt
+  }
+
   /** 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
+  protected def simplify(tree: Tree, pt: Type, locked: TypeVars)(using Context): Tree =
+    val (tree1, pt1) = addDownDeferredEvidenceParams(tree, pt)
+    if !tree1.denot.isOverloaded then // for overloaded trees: resolve overloading before simplifying
+      if !tree1.tpe.widen.isInstanceOf[MethodOrPoly] // wait with simplifying until method is fully applied
+         || tree1.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
+        interpolateTypeVars(tree1, pt1, locked)
+        val simplified = tree1.tpe.simplified
+        if !MatchType.thatReducesUsingGadt(tree1.tpe) then // needs a GADT cast. i15743
           tree.overwriteType(simplified)
-    tree
+    tree1
 
   protected def makeContextualFunction(tree: untpd.Tree, pt: Type)(using Context): Tree = {
     val defn.FunctionOf(formals, _, true) = pt.dropDependentRefinement: @unchecked
-    println(i"make contextual function $tree / $pt")
     val paramNamesOrNil = pt match
       case RefinedType(_, _, rinfo: MethodType) => rinfo.paramNames
       case _ => Nil
diff --git a/tests/pos/contextbounds-for-poly-functions.scala b/tests/pos/contextbounds-for-poly-functions.scala
index a5a035754b08..adaf6c035406 100644
--- a/tests/pos/contextbounds-for-poly-functions.scala
+++ b/tests/pos/contextbounds-for-poly-functions.scala
@@ -28,9 +28,12 @@ val less3: Comparer = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
 // type Comparer2 = [X: Ord] => Cmp[X]
 // val less4: Comparer2 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
-// type CmpWeak[X] = (x: X, y: X) => Boolean
-// type Comparer2Weak = [X: Ord] => (x: X) => CmpWeak[X]
-// val less4: Comparer2Weak = [X: Ord] => (x: X) => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
+type CmpWeak[X] = X => Boolean
+type Comparer2Weak = [X: Ord] => X => CmpWeak[X]
+val less4_0: [X: Ord] => X => X => Boolean =
+  [X: Ord] => (x: X) => (y: X) => summon[Ord[X]].compare(x, y) < 0
+val less4: Comparer2Weak =
+  [X: Ord] => (x: X) => (y: X) => summon[Ord[X]].compare(x, y) < 0
 
 val less5 = [X: [X] =>> Ord[X]] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 

From a736592dcb95a35ddeaef12a84324733b0e4a7b5 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Fri, 4 Oct 2024 13:21:40 +0200
Subject: [PATCH 157/306] Make the expandion of context bounds for poly types
 slightly more elegant

---
 .../src/dotty/tools/dotc/ast/Desugar.scala    | 55 ++++++++++---------
 .../src/dotty/tools/dotc/typer/Typer.scala    | 51 ++++++++++++++---
 .../contextbounds-for-poly-functions.scala    |  2 +-
 3 files changed, 75 insertions(+), 33 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 56e519737cb1..1d2fd32fe103 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -527,8 +527,7 @@ object desugar {
         makeContextualFunction(paramTpts, paramNames, tree, paramsErased).withSpan(tree.span)
 
     if meth.hasAttachment(PolyFunctionApply) then
-      meth.removeAttachment(PolyFunctionApply)
-      // (kπ): deffer this until we can type the result?
+      // meth.removeAttachment(PolyFunctionApply)
       if ctx.mode.is(Mode.Type) then
         cpy.DefDef(meth)(tpt = meth.tpt.withAttachment(PolyFunctionApply, params))
       else
@@ -1250,29 +1249,35 @@ object desugar {
   /** 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 }
    */
-  def makePolyFunctionType(tree: PolyFunction)(using Context): RefinedTypeTree =
-    val PolyFunction(tparams: List[untpd.TypeDef] @unchecked, fun @ untpd.Function(vparamTypes, res)) = tree: @unchecked
-    val paramFlags = fun match
-      case fun: FunctionWithMods =>
-        // TODO: make use of this in the desugaring when pureFuns is enabled.
-        // val isImpure = funFlags.is(Impure)
-
-        // Function flags to be propagated to each parameter in the desugared method type.
-        val givenFlag = fun.mods.flags.toTermFlags & Given
-        fun.erasedParams.map(isErased => if isErased then givenFlag | Erased else givenFlag)
-      case _ =>
-        vparamTypes.map(_ => EmptyFlags)
-
-    val vparams = vparamTypes.lazyZip(paramFlags).zipWithIndex.map {
-      case ((p: ValDef, paramFlags), n) => p.withAddedFlags(paramFlags)
-      case ((p, paramFlags), n) => makeSyntheticParameter(n + 1, p).withAddedFlags(paramFlags)
-    }.toList
-
-    RefinedTypeTree(ref(defn.PolyFunctionType), List(
-      DefDef(nme.apply, tparams :: vparams :: Nil, res, EmptyTree)
-        .withFlags(Synthetic)
-        .withAttachment(PolyFunctionApply, List.empty)
-    )).withSpan(tree.span)
+  def makePolyFunctionType(tree: PolyFunction)(using Context): RefinedTypeTree = tree match
+    case PolyFunction(tparams: List[untpd.TypeDef] @unchecked, fun @ untpd.Function(vparamTypes, res)) =>
+      val paramFlags = fun match
+        case fun: FunctionWithMods =>
+          // TODO: make use of this in the desugaring when pureFuns is enabled.
+          // val isImpure = funFlags.is(Impure)
+
+          // Function flags to be propagated to each parameter in the desugared method type.
+          val givenFlag = fun.mods.flags.toTermFlags & Given
+          fun.erasedParams.map(isErased => if isErased then givenFlag | Erased else givenFlag)
+        case _ =>
+          vparamTypes.map(_ => EmptyFlags)
+
+      val vparams = vparamTypes.lazyZip(paramFlags).zipWithIndex.map {
+        case ((p: ValDef, paramFlags), n) => p.withAddedFlags(paramFlags)
+        case ((p, paramFlags), n) => makeSyntheticParameter(n + 1, p).withAddedFlags(paramFlags)
+      }.toList
+
+      RefinedTypeTree(ref(defn.PolyFunctionType), List(
+        DefDef(nme.apply, tparams :: vparams :: Nil, res, EmptyTree)
+          .withFlags(Synthetic)
+          .withAttachment(PolyFunctionApply, List.empty)
+      )).withSpan(tree.span)
+    case PolyFunction(tparams: List[untpd.TypeDef] @unchecked, res) =>
+      RefinedTypeTree(ref(defn.PolyFunctionType), List(
+        DefDef(nme.apply, tparams :: Nil, res, EmptyTree)
+          .withFlags(Synthetic)
+          .withAttachment(PolyFunctionApply, List.empty)
+      )).withSpan(tree.span)
   end makePolyFunctionType
 
   /** Invent a name for an anonympus given of type or template `impl`. */
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 56e62bccf83b..2951452e44f9 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -3598,14 +3598,17 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
   private def pushDownDeferredEvidenceParams(tpe: Type, params: List[untpd.ValDef], span: Span)(using Context): Type = tpe.dealias match {
     case tpe: MethodType =>
-      MethodType(tpe.paramNames)(paramNames => tpe.paramInfos, _ => pushDownDeferredEvidenceParams(tpe.resultType, params, span))
+      tpe.derivedLambdaType(tpe.paramNames, tpe.paramInfos, pushDownDeferredEvidenceParams(tpe.resultType, params, span))
     case tpe: PolyType =>
-      PolyType(tpe.paramNames)(paramNames => tpe.paramInfos, _ => pushDownDeferredEvidenceParams(tpe.resultType, params, span))
+      tpe.derivedLambdaType(tpe.paramNames, tpe.paramInfos, pushDownDeferredEvidenceParams(tpe.resultType, params, span))
     case tpe: RefinedType =>
-      // TODO(kπ): Doesn't seem right, but the PolyFunction ends up being a refinement
-      RefinedType(pushDownDeferredEvidenceParams(tpe.parent, params, span), tpe.refinedName, pushDownDeferredEvidenceParams(tpe.refinedInfo, params, span))
+      tpe.derivedRefinedType(
+        pushDownDeferredEvidenceParams(tpe.parent, params, span),
+        tpe.refinedName,
+        pushDownDeferredEvidenceParams(tpe.refinedInfo, params, span)
+      )
     case tpe @ AppliedType(tycon, args) if defn.isFunctionType(tpe) && args.size > 1 =>
-      AppliedType(tpe.tycon, args.init :+ pushDownDeferredEvidenceParams(args.last, params, span))
+      tpe.derivedAppliedType(tycon, args.init :+ pushDownDeferredEvidenceParams(args.last, params, span))
     case tpe =>
       val paramNames = params.map(_.name)
       val paramTpts = params.map(_.tpt)
@@ -3614,18 +3617,52 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       typed(ctxFunction).tpe
   }
 
-  private def addDownDeferredEvidenceParams(tree: Tree, pt: Type)(using Context): (Tree, Type) = {
+  private def extractTopMethodTermParams(tpe: Type)(using Context): (List[TermName], List[Type]) = tpe match {
+    case tpe: MethodType =>
+      tpe.paramNames -> tpe.paramInfos
+    case tpe: RefinedType if defn.isFunctionType(tpe.parent) =>
+      extractTopMethodTermParams(tpe.refinedInfo)
+    case _ =>
+      Nil -> Nil
+  }
+
+  private def removeTopMethodTermParams(tpe: Type)(using Context): Type = tpe match {
+    case tpe: MethodType =>
+      tpe.resultType
+    case tpe: RefinedType if defn.isFunctionType(tpe.parent) =>
+      tpe.derivedRefinedType(tpe.parent, tpe.refinedName, removeTopMethodTermParams(tpe.refinedInfo))
+    case tpe: AppliedType if defn.isFunctionType(tpe) =>
+      tpe.args.last
+    case _ =>
+      tpe
+  }
+
+  private def healToPolyFunctionType(tree: Tree)(using Context): Tree = tree match {
+    case defdef: DefDef if defdef.name == nme.apply && defdef.paramss.forall(_.forall(_.symbol.flags.is(TypeParam))) && defdef.paramss.size == 1 =>
+      val (names, types) = extractTopMethodTermParams(defdef.tpt.tpe)
+      val newTpe = removeTopMethodTermParams(defdef.tpt.tpe)
+      val newParams = names.lazyZip(types).map((name, tpe) => SyntheticValDef(name, TypeTree(tpe), flags = SyntheticTermParam))
+      val newDefDef = cpy.DefDef(defdef)(paramss = defdef.paramss ++ List(newParams), tpt = untpd.TypeTree(newTpe))
+      val nestedCtx = ctx.fresh.setNewTyperState()
+      typed(newDefDef)(using nestedCtx)
+    case _ => tree
+  }
+
+  private def addDeferredEvidenceParams(tree: Tree, pt: Type)(using Context): (Tree, Type) = {
     tree.getAttachment(desugar.PolyFunctionApply) match
       case Some(params) if params.nonEmpty =>
         tree.removeAttachment(desugar.PolyFunctionApply)
         val tpe = pushDownDeferredEvidenceParams(tree.tpe, params, tree.span)
         TypeTree(tpe).withSpan(tree.span) -> tpe
+      // case Some(params) if params.isEmpty =>
+      //   println(s"tree: $tree")
+      //   healToPolyFunctionType(tree) -> pt
       case _ => tree -> pt
   }
 
   /** Interpolate and simplify the type of the given tree. */
   protected def simplify(tree: Tree, pt: Type, locked: TypeVars)(using Context): Tree =
-    val (tree1, pt1) = addDownDeferredEvidenceParams(tree, pt)
+    val (tree1, pt1) = addDeferredEvidenceParams(tree, pt)
     if !tree1.denot.isOverloaded then // for overloaded trees: resolve overloading before simplifying
       if !tree1.tpe.widen.isInstanceOf[MethodOrPoly] // wait with simplifying until method is fully applied
          || tree1.isDef                              // ... unless tree is a definition
diff --git a/tests/pos/contextbounds-for-poly-functions.scala b/tests/pos/contextbounds-for-poly-functions.scala
index adaf6c035406..8c7bead36633 100644
--- a/tests/pos/contextbounds-for-poly-functions.scala
+++ b/tests/pos/contextbounds-for-poly-functions.scala
@@ -32,7 +32,7 @@ type CmpWeak[X] = X => Boolean
 type Comparer2Weak = [X: Ord] => X => CmpWeak[X]
 val less4_0: [X: Ord] => X => X => Boolean =
   [X: Ord] => (x: X) => (y: X) => summon[Ord[X]].compare(x, y) < 0
-val less4: Comparer2Weak =
+val less4_1: Comparer2Weak =
   [X: Ord] => (x: X) => (y: X) => summon[Ord[X]].compare(x, y) < 0
 
 val less5 = [X: [X] =>> Ord[X]] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0

From 0af839783a356e2d42133585f6f63759d6df156c Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Tue, 8 Oct 2024 10:51:53 +0200
Subject: [PATCH 158/306] Add more aliases tests for context bounds with poly
 functions

---
 tests/pos/contextbounds-for-poly-functions.scala | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/pos/contextbounds-for-poly-functions.scala b/tests/pos/contextbounds-for-poly-functions.scala
index 8c7bead36633..a3b79043c01a 100644
--- a/tests/pos/contextbounds-for-poly-functions.scala
+++ b/tests/pos/contextbounds-for-poly-functions.scala
@@ -24,6 +24,12 @@ type ComparerRef = [X] => (x: X, y: X) => Ord[X] ?=> Boolean
 type Comparer = [X: Ord] => (x: X, y: X) => Boolean
 val less3: Comparer = [X: Ord as ord] => (x: X, y: X) => ord.compare(x, y) < 0
 
+type CmpRest[X] = X => Boolean
+type CmpMid[X] = X => CmpRest[X]
+type Cmp3 = [X: Ord] => X => CmpMid[X]
+val lessCmp3: Cmp3 = [X: Ord] => (x: X) => (y: X) => (z: X) => summon[Ord[X]].compare(x, y) < 0
+val lessCmp3_1: Cmp3 = [X: Ord as ord] => (x: X) => (y: X) => (z: X) => ord.compare(x, y) < 0
+
 // type Cmp[X] = (x: X, y: X) => Boolean
 // type Comparer2 = [X: Ord] => Cmp[X]
 // val less4: Comparer2 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0

From 9c66069d330423f46d340c99f630ef8c375dae1d Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Mon, 14 Oct 2024 12:18:25 +0200
Subject: [PATCH 159/306] Bring back the restriction for requiring value
 parameters in poly function type definitions

---
 .../src/dotty/tools/dotc/ast/Desugar.scala    |  2 -
 .../src/dotty/tools/dotc/typer/Typer.scala    | 47 +++++--------------
 2 files changed, 13 insertions(+), 36 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 1d2fd32fe103..e0a906e06dcc 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -514,7 +514,6 @@ object desugar {
       case Nil =>
         params :: Nil
 
-    // TODO(kπ) is this enough? SHould this be a TreeTraverse-thing?
     def pushDownEvidenceParams(tree: Tree): Tree = tree match
       case Function(params, body) =>
         cpy.Function(tree)(params, pushDownEvidenceParams(body))
@@ -527,7 +526,6 @@ object desugar {
         makeContextualFunction(paramTpts, paramNames, tree, paramsErased).withSpan(tree.span)
 
     if meth.hasAttachment(PolyFunctionApply) then
-      // meth.removeAttachment(PolyFunctionApply)
       if ctx.mode.is(Mode.Type) then
         cpy.DefDef(meth)(tpt = meth.tpt.withAttachment(PolyFunctionApply, params))
       else
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 2951452e44f9..076fc2e4369f 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -3596,6 +3596,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
      }
   }
 
+  /** Push down the deferred evidence parameters up until the result type is not
+   *  a method type, poly type or a function type
+   */
   private def pushDownDeferredEvidenceParams(tpe: Type, params: List[untpd.ValDef], span: Span)(using Context): Type = tpe.dealias match {
     case tpe: MethodType =>
       tpe.derivedLambdaType(tpe.paramNames, tpe.paramInfos, pushDownDeferredEvidenceParams(tpe.resultType, params, span))
@@ -3617,46 +3620,22 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       typed(ctxFunction).tpe
   }
 
-  private def extractTopMethodTermParams(tpe: Type)(using Context): (List[TermName], List[Type]) = tpe match {
-    case tpe: MethodType =>
-      tpe.paramNames -> tpe.paramInfos
-    case tpe: RefinedType if defn.isFunctionType(tpe.parent) =>
-      extractTopMethodTermParams(tpe.refinedInfo)
-    case _ =>
-      Nil -> Nil
-  }
-
-  private def removeTopMethodTermParams(tpe: Type)(using Context): Type = tpe match {
-    case tpe: MethodType =>
-      tpe.resultType
-    case tpe: RefinedType if defn.isFunctionType(tpe.parent) =>
-      tpe.derivedRefinedType(tpe.parent, tpe.refinedName, removeTopMethodTermParams(tpe.refinedInfo))
-    case tpe: AppliedType if defn.isFunctionType(tpe) =>
-      tpe.args.last
-    case _ =>
-      tpe
-  }
-
-  private def healToPolyFunctionType(tree: Tree)(using Context): Tree = tree match {
-    case defdef: DefDef if defdef.name == nme.apply && defdef.paramss.forall(_.forall(_.symbol.flags.is(TypeParam))) && defdef.paramss.size == 1 =>
-      val (names, types) = extractTopMethodTermParams(defdef.tpt.tpe)
-      val newTpe = removeTopMethodTermParams(defdef.tpt.tpe)
-      val newParams = names.lazyZip(types).map((name, tpe) => SyntheticValDef(name, TypeTree(tpe), flags = SyntheticTermParam))
-      val newDefDef = cpy.DefDef(defdef)(paramss = defdef.paramss ++ List(newParams), tpt = untpd.TypeTree(newTpe))
-      val nestedCtx = ctx.fresh.setNewTyperState()
-      typed(newDefDef)(using nestedCtx)
-    case _ => tree
-  }
-
+  /** If the tree has a `PolyFunctionApply` attachment, add the deferred
+   *  evidence parameters as the last argument list before the result type. This
+   *  follows aliases, so the following two types will be expanded to (up to the
+   *  context bound encoding):
+   *    type CmpWeak[X] = X => Boolean
+   *    type Comparer2Weak = [X: Ord] => X => CmpWeak[X]
+   *  ===>
+   *    type CmpWeak[X] = X => Boolean type Comparer2Weak = [X] => X => X ?=>
+   *    Ord[X] => Boolean
+   */
   private def addDeferredEvidenceParams(tree: Tree, pt: Type)(using Context): (Tree, Type) = {
     tree.getAttachment(desugar.PolyFunctionApply) match
       case Some(params) if params.nonEmpty =>
         tree.removeAttachment(desugar.PolyFunctionApply)
         val tpe = pushDownDeferredEvidenceParams(tree.tpe, params, tree.span)
         TypeTree(tpe).withSpan(tree.span) -> tpe
-      // case Some(params) if params.isEmpty =>
-      //   println(s"tree: $tree")
-      //   healToPolyFunctionType(tree) -> pt
       case _ => tree -> pt
   }
 

From ec6d7effc62129508c68f0337d9c854f94390645 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Fri, 18 Oct 2024 10:10:06 +0200
Subject: [PATCH 160/306] Cleanup dead code

---
 compiler/src/dotty/tools/dotc/typer/Typer.scala | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 076fc2e4369f..4ae706fd7b0c 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1720,10 +1720,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           typedFunctionType(desugar.makeFunctionWithValDefs(tree, pt), pt)
         else
           val funSym = defn.FunctionSymbol(numArgs, isContextual, isImpure)
-          // val args1 = args.mapConserve {
-          //   case cb: untpd.ContextBoundTypeTree => typed(cb)
-          //   case t => t
-          // }
           val result = typed(cpy.AppliedTypeTree(tree)(untpd.TypeTree(funSym.typeRef), args :+ body), pt)
           // if there are any erased classes, we need to re-do the typecheck.
           result match

From dfa92409a1f6ed9ea0226c145ef1f383e67c43bd Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Thu, 14 Nov 2024 11:25:08 +0100
Subject: [PATCH 161/306] Reuse addEvidenceParams logic, but no aliases

---
 .../src/dotty/tools/dotc/ast/Desugar.scala    |  89 +++++++++++----
 .../src/dotty/tools/dotc/typer/Typer.scala    | 101 +++++++++---------
 .../contextbounds-for-poly-functions.scala    |  33 ++++--
 3 files changed, 147 insertions(+), 76 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index e0a906e06dcc..d82150d8f9da 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -22,6 +22,7 @@ import parsing.Parsers
 
 import scala.annotation.internal.sharable
 import scala.annotation.threadUnsafe
+import dotty.tools.dotc.quoted.QuoteUtils.treeOwner
 
 object desugar {
   import untpd.*
@@ -52,8 +53,12 @@ object desugar {
    */
   val ContextBoundParam: Property.Key[Unit] = Property.StickyKey()
 
-  /** An attachment key to indicate that a DefDef is a poly function apply
-   * method definition.
+  /** When first desugaring a PolyFunction, this attachment is added to the
+   *  PolyFunction `apply` method with an empty list value.
+   *
+   *  Afterwards, the attachment is added to poly function type trees, with the
+   *  list of their context bounds.
+   *  //TODO(kπ) see if it has to be updated
    */
   val PolyFunctionApply: Property.Key[List[ValDef]] = Property.StickyKey()
 
@@ -497,9 +502,9 @@ object desugar {
         case Ident(name: TermName) => boundNames.contains(name)
         case _ => false
 
-    def recur(mparamss: List[ParamClause]): List[ParamClause] = mparamss match
+    def recur(mparamss: List[ParamClause]): (List[ParamClause], List[ParamClause]) = mparamss match
       case ValDefs(mparams) :: _ if mparams.exists(referencesBoundName) =>
-        params :: mparamss
+        (params :: Nil) -> mparamss
       case ValDefs(mparams @ (mparam :: _)) :: Nil if mparam.mods.isOneOf(GivenOrImplicit) =>
         val normParams =
           if params.head.mods.flags.is(Given) != mparam.mods.flags.is(Given) then
@@ -508,30 +513,71 @@ object desugar {
               param.withMods(param.mods.withFlags(normFlags))
                 .showing(i"adapted param $result ${result.mods.flags} for ${meth.name}", Printers.desugar)
           else params
-        (normParams ++ mparams) :: Nil
+        ((normParams ++ mparams) :: Nil) -> Nil
       case mparams :: mparamss1 =>
-        mparams :: recur(mparamss1)
+        val (fst, snd) = recur(mparamss1)
+        (mparams :: fst) -> snd
       case Nil =>
-        params :: Nil
-
-    def pushDownEvidenceParams(tree: Tree): Tree = tree match
-      case Function(params, body) =>
-        cpy.Function(tree)(params, pushDownEvidenceParams(body))
-      case Block(stats, expr) =>
-        cpy.Block(tree)(stats, pushDownEvidenceParams(expr))
-      case tree =>
+        Nil -> (params :: Nil)
+
+    // def pushDownEvidenceParams(tree: Tree): Tree = tree match
+    //   case Function(mparams, body) if mparams.collect { case v: ValDef => v }.exists(referencesBoundName) =>
+    //     ctxFunctionWithParams(tree)
+    //   case Function(mparams, body) =>
+    //     cpy.Function(tree)(mparams, pushDownEvidenceParams(body))
+    //   case Block(stats, expr) =>
+    //     cpy.Block(tree)(stats, pushDownEvidenceParams(expr))
+    //   case tree =>
+    //     ctxFunctionWithParams(tree)
+
+    // def ctxFunctionWithParams(tree: Tree): Tree =
+    //   val paramTpts = params.map(_.tpt)
+    //   val paramNames = params.map(_.name)
+    //   val paramsErased = params.map(_.mods.flags.is(Erased))
+    //   Function(params, tree).withSpan(tree.span).withAttachmentsFrom(tree)
+
+    def functionsOf(paramss: List[ParamClause], rhs: Tree): Tree = paramss match
+      case Nil => rhs
+      case ValDefs(head @ (fst :: _)) :: rest if fst.mods.isOneOf(GivenOrImplicit) =>
         val paramTpts = params.map(_.tpt)
         val paramNames = params.map(_.name)
         val paramsErased = params.map(_.mods.flags.is(Erased))
-        makeContextualFunction(paramTpts, paramNames, tree, paramsErased).withSpan(tree.span)
+        makeContextualFunction(paramTpts, paramNames, functionsOf(rest, rhs), paramsErased).withSpan(rhs.span)
+      case head :: rest =>
+        Function(head, functionsOf(rest, rhs))
 
     if meth.hasAttachment(PolyFunctionApply) then
-      if ctx.mode.is(Mode.Type) then
-        cpy.DefDef(meth)(tpt = meth.tpt.withAttachment(PolyFunctionApply, params))
-      else
-        cpy.DefDef(meth)(rhs = pushDownEvidenceParams(meth.rhs))
+      println(i"${recur(meth.paramss)}")
+      recur(meth.paramss) match
+        case (paramsFst, Nil) =>
+          cpy.DefDef(meth)(paramss = paramsFst)
+        case (paramsFst, paramsSnd) =>
+          if ctx.mode.is(Mode.Type) then
+            cpy.DefDef(meth)(paramss = paramsFst, tpt = functionsOf(paramsSnd, meth.tpt))
+          else
+            cpy.DefDef(meth)(paramss = paramsFst, rhs = functionsOf(paramsSnd, meth.rhs))
+
+      // if ctx.mode.is(Mode.Type) then
+      //   meth.removeAttachment(PolyFunctionApply)
+      //   // should be kept on meth to see the current param types?
+      //   meth.tpt.putAttachment(PolyFunctionApply, params)
+      //   val newParamss = recur(meth.paramss)
+      //   println(i"added PolyFunctionApply to ${meth.name}.tpt: ${meth.tpt} with $params")
+      //   println(i"new paramss: $newParamss")
+      //   meth
+      // else
+      //   val newParamss = recur(meth.paramss)
+      //   println(i"added PolyFunctionApply to ${meth.name} with $params")
+      //   println(i"new paramss: $newParamss")
+      //   val DefDef(_, mparamss, _ , _) = meth: @unchecked
+      //   val tparams :: ValDefs(vparams) :: Nil = mparamss: @unchecked
+      //   if vparams.exists(referencesBoundName) then
+      //     cpy.DefDef(meth)(paramss = tparams :: params :: Nil, rhs = Function(vparams, meth.rhs))
+      //   else
+      //     cpy.DefDef(meth)(rhs = pushDownEvidenceParams(meth.rhs))
     else
-      cpy.DefDef(meth)(paramss = recur(meth.paramss))
+      val (paramsFst, paramsSnd) = recur(meth.paramss)
+      cpy.DefDef(meth)(paramss = paramsFst ++ paramsSnd)
   end addEvidenceParams
 
   /** The parameters generated from the contextual bounds of `meth`, as generated by `desugar.defDef` */
@@ -1265,17 +1311,20 @@ object desugar {
         case ((p, paramFlags), n) => makeSyntheticParameter(n + 1, p).withAddedFlags(paramFlags)
       }.toList
 
+      vparams.foreach(p => println(i"  $p, ${p.mods.flags.flagsString}"))
       RefinedTypeTree(ref(defn.PolyFunctionType), List(
         DefDef(nme.apply, tparams :: vparams :: Nil, res, EmptyTree)
           .withFlags(Synthetic)
           .withAttachment(PolyFunctionApply, List.empty)
       )).withSpan(tree.span)
+      .withAttachment(PolyFunctionApply, tree.attachmentOrElse(PolyFunctionApply, List.empty))
     case PolyFunction(tparams: List[untpd.TypeDef] @unchecked, res) =>
       RefinedTypeTree(ref(defn.PolyFunctionType), List(
         DefDef(nme.apply, tparams :: Nil, res, EmptyTree)
           .withFlags(Synthetic)
           .withAttachment(PolyFunctionApply, List.empty)
       )).withSpan(tree.span)
+      .withAttachment(PolyFunctionApply, tree.attachmentOrElse(PolyFunctionApply, List.empty))
   end makePolyFunctionType
 
   /** Invent a name for an anonympus given of type or template `impl`. */
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 4ae706fd7b0c..cfa921f500a2 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -3592,61 +3592,62 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
      }
   }
 
-  /** Push down the deferred evidence parameters up until the result type is not
-   *  a method type, poly type or a function type
-   */
-  private def pushDownDeferredEvidenceParams(tpe: Type, params: List[untpd.ValDef], span: Span)(using Context): Type = tpe.dealias match {
-    case tpe: MethodType =>
-      tpe.derivedLambdaType(tpe.paramNames, tpe.paramInfos, pushDownDeferredEvidenceParams(tpe.resultType, params, span))
-    case tpe: PolyType =>
-      tpe.derivedLambdaType(tpe.paramNames, tpe.paramInfos, pushDownDeferredEvidenceParams(tpe.resultType, params, span))
-    case tpe: RefinedType =>
-      tpe.derivedRefinedType(
-        pushDownDeferredEvidenceParams(tpe.parent, params, span),
-        tpe.refinedName,
-        pushDownDeferredEvidenceParams(tpe.refinedInfo, params, span)
-      )
-    case tpe @ AppliedType(tycon, args) if defn.isFunctionType(tpe) && args.size > 1 =>
-      tpe.derivedAppliedType(tycon, args.init :+ pushDownDeferredEvidenceParams(args.last, params, span))
-    case tpe =>
-      val paramNames = params.map(_.name)
-      val paramTpts = params.map(_.tpt)
-      val paramsErased = params.map(_.mods.flags.is(Erased))
-      val ctxFunction = desugar.makeContextualFunction(paramTpts, paramNames, untpd.TypedSplice(TypeTree(tpe.dealias)), paramsErased).withSpan(span)
-      typed(ctxFunction).tpe
-  }
-
-  /** If the tree has a `PolyFunctionApply` attachment, add the deferred
-   *  evidence parameters as the last argument list before the result type. This
-   *  follows aliases, so the following two types will be expanded to (up to the
-   *  context bound encoding):
-   *    type CmpWeak[X] = X => Boolean
-   *    type Comparer2Weak = [X: Ord] => X => CmpWeak[X]
-   *  ===>
-   *    type CmpWeak[X] = X => Boolean type Comparer2Weak = [X] => X => X ?=>
-   *    Ord[X] => Boolean
-   */
-  private def addDeferredEvidenceParams(tree: Tree, pt: Type)(using Context): (Tree, Type) = {
-    tree.getAttachment(desugar.PolyFunctionApply) match
-      case Some(params) if params.nonEmpty =>
-        tree.removeAttachment(desugar.PolyFunctionApply)
-        val tpe = pushDownDeferredEvidenceParams(tree.tpe, params, tree.span)
-        TypeTree(tpe).withSpan(tree.span) -> tpe
-      case _ => tree -> pt
-  }
+  // /** Push down the deferred evidence parameters up until the result type is not
+  //  *  a method type, poly type or a function type
+  //  */
+  // private def pushDownDeferredEvidenceParams(tpe: Type, params: List[untpd.ValDef], span: Span)(using Context): Type =
+  //   tpe.dealias match {
+  //     case tpe if tpe.baseClasses.contains(defn.PolyFunctionClass) =>
+  //       attachEvidenceParams(tpe, params, span)
+  //     case tpe: MethodType =>
+  //       tpe.derivedLambdaType(tpe.paramNames, tpe.paramInfos, pushDownDeferredEvidenceParams(tpe.resultType, params, span))
+  //     case tpe @ AppliedType(tycon, args) if defn.isFunctionType(tpe) && args.size > 1 =>
+  //       tpe.derivedAppliedType(tycon, args.init :+ pushDownDeferredEvidenceParams(args.last, params, span))
+  //     case tpe =>
+  //       attachEvidenceParams(tpe, params, span)
+  //   }
+
+  // /** (params) ?=> tpe */
+  // private def attachEvidenceParams(tpe: Type, params: List[untpd.ValDef], span: Span)(using Context): Type =
+  //   val paramNames = params.map(_.name)
+  //   val paramTpts = params.map(_.tpt)
+  //   val paramsErased = params.map(_.mods.flags.is(Erased))
+  //   val ctxFunction = desugar.makeContextualFunction(paramTpts, paramNames, untpd.TypedSplice(TypeTree(tpe.dealias)), paramsErased).withSpan(span)
+  //   typed(ctxFunction).tpe
+
+  // /** If the tree has a `PolyFunctionApply` attachment, add the deferred
+  //  *  evidence parameters as the last argument list before the result type or a next poly type.
+  //  *  This follows aliases, so the following two types will be expanded to (up to the
+  //  *  context bound encoding):
+  //  *    type CmpWeak[X] = X => Boolean
+  //  *    type Comparer2Weak = [X: Ord] => X => CmpWeak[X]
+  //  *  ===>
+  //  *    type CmpWeak[X] = X => Boolean type Comparer2Weak = [X] => X => X ?=>
+  //  *    Ord[X] => Boolean
+  //  */
+  // private def addDeferredEvidenceParams(tree: Tree, pt: Type)(using Context): (Tree, Type) = {
+  //   tree.getAttachment(desugar.PolyFunctionApply) match
+  //     case Some(params) if params.nonEmpty =>
+  //       tree.putAttachment(desugar.PolyFunctionApply, Nil)
+  //       val tpe = pushDownDeferredEvidenceParams(tree.tpe, params, tree.span)
+  //       TypeTree(tpe).withSpan(tree.span) -> tpe
+  //     case Some(params) =>
+  //       tree -> pt
+  //     case _ => tree -> pt
+  // }
 
   /** Interpolate and simplify the type of the given tree. */
   protected def simplify(tree: Tree, pt: Type, locked: TypeVars)(using Context): Tree =
-    val (tree1, pt1) = addDeferredEvidenceParams(tree, pt)
-    if !tree1.denot.isOverloaded then // for overloaded trees: resolve overloading before simplifying
-      if !tree1.tpe.widen.isInstanceOf[MethodOrPoly] // wait with simplifying until method is fully applied
-         || tree1.isDef                              // ... unless tree is a definition
+    // val (tree1, pt1) = addDeferredEvidenceParams(tree, pt)
+    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(tree1, pt1, locked)
-        val simplified = tree1.tpe.simplified
-        if !MatchType.thatReducesUsingGadt(tree1.tpe) then // needs a GADT cast. i15743
+        interpolateTypeVars(tree, pt, locked)
+        val simplified = tree.tpe.simplified
+        if !MatchType.thatReducesUsingGadt(tree.tpe) then // needs a GADT cast. i15743
           tree.overwriteType(simplified)
-    tree1
+    tree
 
   protected def makeContextualFunction(tree: untpd.Tree, pt: Type)(using Context): Tree = {
     val defn.FunctionOf(formals, _, true) = pt.dropDependentRefinement: @unchecked
diff --git a/tests/pos/contextbounds-for-poly-functions.scala b/tests/pos/contextbounds-for-poly-functions.scala
index a3b79043c01a..44eb978b6c52 100644
--- a/tests/pos/contextbounds-for-poly-functions.scala
+++ b/tests/pos/contextbounds-for-poly-functions.scala
@@ -3,6 +3,7 @@ import scala.language.future
 
 trait Ord[X]:
   def compare(x: X, y: X): Int
+  type T
 
 trait Show[X]:
   def show(x: X): String
@@ -11,6 +12,8 @@ val less0: [X: Ord] => (X, X) => Boolean = ???
 
 val less1 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
+type PolyTest1 = [X] => X => Ord[X] ?=> Boolean
+
 val less1_type_test: [X: Ord] => (X, X) => Boolean =
   [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
@@ -34,12 +37,12 @@ val lessCmp3_1: Cmp3 = [X: Ord as ord] => (x: X) => (y: X) => (z: X) => ord.comp
 // type Comparer2 = [X: Ord] => Cmp[X]
 // val less4: Comparer2 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
-type CmpWeak[X] = X => Boolean
-type Comparer2Weak = [X: Ord] => X => CmpWeak[X]
-val less4_0: [X: Ord] => X => X => Boolean =
-  [X: Ord] => (x: X) => (y: X) => summon[Ord[X]].compare(x, y) < 0
-val less4_1: Comparer2Weak =
-  [X: Ord] => (x: X) => (y: X) => summon[Ord[X]].compare(x, y) < 0
+// type CmpWeak[X] = X => Boolean
+// type Comparer2Weak = [X: Ord] => X => CmpWeak[X]
+// val less4_0: [X: Ord] => X => X => Boolean =
+//   [X: Ord] => (x: X) => (y: X) => summon[Ord[X]].compare(x, y) < 0
+// val less4_1: Comparer2Weak =
+//   [X: Ord] => (x: X) => (y: X) => summon[Ord[X]].compare(x, y) < 0
 
 val less5 = [X: [X] =>> Ord[X]] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
@@ -65,3 +68,21 @@ val less9 = [X: {Ord as ord, Show as show}] => (x: X, y: X) => ord.compare(x, y)
 
 val less9_type_test: [X: {Ord as ord, Show as show}] => (X, X) => Boolean =
   [X: {Ord as ord, Show as show}] => (x: X, y: X) => ord.compare(x, y) < 0
+
+type CmpNested = [X: Ord] => X => [Y: Ord] => Y => Boolean
+val less10: CmpNested = [X: Ord] => (x: X) => [Y: Ord] => (y: Y) => true
+val less10Explicit: CmpNested = [X] => (x: X) => (ordx: Ord[X]) ?=> [Y] => (y: Y) => (ordy: Ord[Y]) ?=> true
+
+// type CmpAlias[X] = X => Boolean
+// type CmpNestedAliased = [X: Ord] => X => [Y] => Y => CmpAlias[Y]
+
+// val less11: CmpNestedAliased = [X: Ord] => (x: X) => [Y] => (y: Y) => (y1: Y) => true
+// val less11Explicit: CmpNestedAliased = [X] => (x: X) => (ordx: Ord[X]) ?=> [Y] => (y: Y) => (y1: Y) => true
+
+val notationalExample: [X: Ord] => X => [Y: Ord] => Y => Int =
+  [X] => (x: X) => (ordx: Ord[X]) ?=> [Y] => (y: Y) => (ordy: Ord[Y]) ?=> 1
+
+val namedConstraintRef = [X: {Ord as ord}] => (x: ord.T) => x
+type DependentCmp = [X: {Ord as ord}] => ord.T => Boolean
+type DependentCmp1 = [X: {Ord as ord}] => (ord.T, Int) => ord.T => Boolean
+val dependentCmp: DependentCmp = [X: {Ord as ord}] => (x: ord.T) => true

From 7755e3bc166637f6753df2d2f74b127dc97b35f8 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Thu, 14 Nov 2024 11:46:12 +0100
Subject: [PATCH 162/306] Cleanup context bounds for poly functions
 implementation, make the implementation consistent with addEvidenceParams

---
 .../src/dotty/tools/dotc/ast/Desugar.scala    | 79 ++++---------------
 .../src/dotty/tools/dotc/typer/Typer.scala    | 45 -----------
 .../contextbounds-for-poly-functions.scala    | 20 ++---
 3 files changed, 26 insertions(+), 118 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index d82150d8f9da..768d598987f0 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -53,14 +53,9 @@ object desugar {
    */
   val ContextBoundParam: Property.Key[Unit] = Property.StickyKey()
 
-  /** When first desugaring a PolyFunction, this attachment is added to the
-   *  PolyFunction `apply` method with an empty list value.
-   *
-   *  Afterwards, the attachment is added to poly function type trees, with the
-   *  list of their context bounds.
-   *  //TODO(kπ) see if it has to be updated
+  /** Marks a poly fcuntion apply method, so that we can handle adding evidence parameters to them in a special way
    */
-  val PolyFunctionApply: Property.Key[List[ValDef]] = Property.StickyKey()
+  val PolyFunctionApply: Property.Key[Unit] = Property.StickyKey()
 
   /** What static check should be applied to a Match? */
   enum MatchCheck {
@@ -520,22 +515,6 @@ object desugar {
       case Nil =>
         Nil -> (params :: Nil)
 
-    // def pushDownEvidenceParams(tree: Tree): Tree = tree match
-    //   case Function(mparams, body) if mparams.collect { case v: ValDef => v }.exists(referencesBoundName) =>
-    //     ctxFunctionWithParams(tree)
-    //   case Function(mparams, body) =>
-    //     cpy.Function(tree)(mparams, pushDownEvidenceParams(body))
-    //   case Block(stats, expr) =>
-    //     cpy.Block(tree)(stats, pushDownEvidenceParams(expr))
-    //   case tree =>
-    //     ctxFunctionWithParams(tree)
-
-    // def ctxFunctionWithParams(tree: Tree): Tree =
-    //   val paramTpts = params.map(_.tpt)
-    //   val paramNames = params.map(_.name)
-    //   val paramsErased = params.map(_.mods.flags.is(Erased))
-    //   Function(params, tree).withSpan(tree.span).withAttachmentsFrom(tree)
-
     def functionsOf(paramss: List[ParamClause], rhs: Tree): Tree = paramss match
       case Nil => rhs
       case ValDefs(head @ (fst :: _)) :: rest if fst.mods.isOneOf(GivenOrImplicit) =>
@@ -543,38 +522,21 @@ object desugar {
         val paramNames = params.map(_.name)
         val paramsErased = params.map(_.mods.flags.is(Erased))
         makeContextualFunction(paramTpts, paramNames, functionsOf(rest, rhs), paramsErased).withSpan(rhs.span)
-      case head :: rest =>
+      case ValDefs(head) :: rest =>
         Function(head, functionsOf(rest, rhs))
+      case head :: _ =>
+        assert(false, i"unexpected type parameters when adding evidence parameters to $meth")
+        EmptyTree
 
     if meth.hasAttachment(PolyFunctionApply) then
-      println(i"${recur(meth.paramss)}")
-      recur(meth.paramss) match
-        case (paramsFst, Nil) =>
-          cpy.DefDef(meth)(paramss = paramsFst)
-        case (paramsFst, paramsSnd) =>
-          if ctx.mode.is(Mode.Type) then
-            cpy.DefDef(meth)(paramss = paramsFst, tpt = functionsOf(paramsSnd, meth.tpt))
-          else
-            cpy.DefDef(meth)(paramss = paramsFst, rhs = functionsOf(paramsSnd, meth.rhs))
-
-      // if ctx.mode.is(Mode.Type) then
-      //   meth.removeAttachment(PolyFunctionApply)
-      //   // should be kept on meth to see the current param types?
-      //   meth.tpt.putAttachment(PolyFunctionApply, params)
-      //   val newParamss = recur(meth.paramss)
-      //   println(i"added PolyFunctionApply to ${meth.name}.tpt: ${meth.tpt} with $params")
-      //   println(i"new paramss: $newParamss")
-      //   meth
-      // else
-      //   val newParamss = recur(meth.paramss)
-      //   println(i"added PolyFunctionApply to ${meth.name} with $params")
-      //   println(i"new paramss: $newParamss")
-      //   val DefDef(_, mparamss, _ , _) = meth: @unchecked
-      //   val tparams :: ValDefs(vparams) :: Nil = mparamss: @unchecked
-      //   if vparams.exists(referencesBoundName) then
-      //     cpy.DefDef(meth)(paramss = tparams :: params :: Nil, rhs = Function(vparams, meth.rhs))
-      //   else
-      //     cpy.DefDef(meth)(rhs = pushDownEvidenceParams(meth.rhs))
+      meth.removeAttachment(PolyFunctionApply)
+      // for PolyFunctions we are limited to a single term param list, so we reuse the recur logic to compute the new parameter lists
+      // and then we add the other parameter lists as function types to the return type
+      val (paramsFst, paramsSnd) = recur(meth.paramss)
+      if ctx.mode.is(Mode.Type) then
+        cpy.DefDef(meth)(paramss = paramsFst, tpt = functionsOf(paramsSnd, meth.tpt))
+      else
+        cpy.DefDef(meth)(paramss = paramsFst, rhs = functionsOf(paramsSnd, meth.rhs))
     else
       val (paramsFst, paramsSnd) = recur(meth.paramss)
       cpy.DefDef(meth)(paramss = paramsFst ++ paramsSnd)
@@ -1293,7 +1255,7 @@ object desugar {
   /** 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 }
    */
-  def makePolyFunctionType(tree: PolyFunction)(using Context): RefinedTypeTree = tree match
+  def makePolyFunctionType(tree: PolyFunction)(using Context): RefinedTypeTree = (tree: @unchecked) match
     case PolyFunction(tparams: List[untpd.TypeDef] @unchecked, fun @ untpd.Function(vparamTypes, res)) =>
       val paramFlags = fun match
         case fun: FunctionWithMods =>
@@ -1311,20 +1273,11 @@ object desugar {
         case ((p, paramFlags), n) => makeSyntheticParameter(n + 1, p).withAddedFlags(paramFlags)
       }.toList
 
-      vparams.foreach(p => println(i"  $p, ${p.mods.flags.flagsString}"))
       RefinedTypeTree(ref(defn.PolyFunctionType), List(
         DefDef(nme.apply, tparams :: vparams :: Nil, res, EmptyTree)
           .withFlags(Synthetic)
-          .withAttachment(PolyFunctionApply, List.empty)
-      )).withSpan(tree.span)
-      .withAttachment(PolyFunctionApply, tree.attachmentOrElse(PolyFunctionApply, List.empty))
-    case PolyFunction(tparams: List[untpd.TypeDef] @unchecked, res) =>
-      RefinedTypeTree(ref(defn.PolyFunctionType), List(
-        DefDef(nme.apply, tparams :: Nil, res, EmptyTree)
-          .withFlags(Synthetic)
-          .withAttachment(PolyFunctionApply, List.empty)
+          .withAttachment(PolyFunctionApply, ())
       )).withSpan(tree.span)
-      .withAttachment(PolyFunctionApply, tree.attachmentOrElse(PolyFunctionApply, List.empty))
   end makePolyFunctionType
 
   /** Invent a name for an anonympus given of type or template `impl`. */
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index cfa921f500a2..f7610520f61c 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -3592,53 +3592,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
      }
   }
 
-  // /** Push down the deferred evidence parameters up until the result type is not
-  //  *  a method type, poly type or a function type
-  //  */
-  // private def pushDownDeferredEvidenceParams(tpe: Type, params: List[untpd.ValDef], span: Span)(using Context): Type =
-  //   tpe.dealias match {
-  //     case tpe if tpe.baseClasses.contains(defn.PolyFunctionClass) =>
-  //       attachEvidenceParams(tpe, params, span)
-  //     case tpe: MethodType =>
-  //       tpe.derivedLambdaType(tpe.paramNames, tpe.paramInfos, pushDownDeferredEvidenceParams(tpe.resultType, params, span))
-  //     case tpe @ AppliedType(tycon, args) if defn.isFunctionType(tpe) && args.size > 1 =>
-  //       tpe.derivedAppliedType(tycon, args.init :+ pushDownDeferredEvidenceParams(args.last, params, span))
-  //     case tpe =>
-  //       attachEvidenceParams(tpe, params, span)
-  //   }
-
-  // /** (params) ?=> tpe */
-  // private def attachEvidenceParams(tpe: Type, params: List[untpd.ValDef], span: Span)(using Context): Type =
-  //   val paramNames = params.map(_.name)
-  //   val paramTpts = params.map(_.tpt)
-  //   val paramsErased = params.map(_.mods.flags.is(Erased))
-  //   val ctxFunction = desugar.makeContextualFunction(paramTpts, paramNames, untpd.TypedSplice(TypeTree(tpe.dealias)), paramsErased).withSpan(span)
-  //   typed(ctxFunction).tpe
-
-  // /** If the tree has a `PolyFunctionApply` attachment, add the deferred
-  //  *  evidence parameters as the last argument list before the result type or a next poly type.
-  //  *  This follows aliases, so the following two types will be expanded to (up to the
-  //  *  context bound encoding):
-  //  *    type CmpWeak[X] = X => Boolean
-  //  *    type Comparer2Weak = [X: Ord] => X => CmpWeak[X]
-  //  *  ===>
-  //  *    type CmpWeak[X] = X => Boolean type Comparer2Weak = [X] => X => X ?=>
-  //  *    Ord[X] => Boolean
-  //  */
-  // private def addDeferredEvidenceParams(tree: Tree, pt: Type)(using Context): (Tree, Type) = {
-  //   tree.getAttachment(desugar.PolyFunctionApply) match
-  //     case Some(params) if params.nonEmpty =>
-  //       tree.putAttachment(desugar.PolyFunctionApply, Nil)
-  //       val tpe = pushDownDeferredEvidenceParams(tree.tpe, params, tree.span)
-  //       TypeTree(tpe).withSpan(tree.span) -> tpe
-  //     case Some(params) =>
-  //       tree -> pt
-  //     case _ => tree -> pt
-  // }
-
   /** Interpolate and simplify the type of the given tree. */
   protected def simplify(tree: Tree, pt: Type, locked: TypeVars)(using Context): Tree =
-    // val (tree1, pt1) = addDeferredEvidenceParams(tree, pt)
     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
diff --git a/tests/pos/contextbounds-for-poly-functions.scala b/tests/pos/contextbounds-for-poly-functions.scala
index 44eb978b6c52..6fadcda2b43e 100644
--- a/tests/pos/contextbounds-for-poly-functions.scala
+++ b/tests/pos/contextbounds-for-poly-functions.scala
@@ -37,12 +37,12 @@ val lessCmp3_1: Cmp3 = [X: Ord as ord] => (x: X) => (y: X) => (z: X) => ord.comp
 // type Comparer2 = [X: Ord] => Cmp[X]
 // val less4: Comparer2 = [X: Ord] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
-// type CmpWeak[X] = X => Boolean
-// type Comparer2Weak = [X: Ord] => X => CmpWeak[X]
-// val less4_0: [X: Ord] => X => X => Boolean =
-//   [X: Ord] => (x: X) => (y: X) => summon[Ord[X]].compare(x, y) < 0
-// val less4_1: Comparer2Weak =
-//   [X: Ord] => (x: X) => (y: X) => summon[Ord[X]].compare(x, y) < 0
+type CmpWeak[X] = X => Boolean
+type Comparer2Weak = [X: Ord] => X => CmpWeak[X]
+val less4_0: [X: Ord] => X => X => Boolean =
+  [X: Ord] => (x: X) => (y: X) => summon[Ord[X]].compare(x, y) < 0
+val less4_1: Comparer2Weak =
+  [X: Ord] => (x: X) => (y: X) => summon[Ord[X]].compare(x, y) < 0
 
 val less5 = [X: [X] =>> Ord[X]] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
 
@@ -73,11 +73,11 @@ type CmpNested = [X: Ord] => X => [Y: Ord] => Y => Boolean
 val less10: CmpNested = [X: Ord] => (x: X) => [Y: Ord] => (y: Y) => true
 val less10Explicit: CmpNested = [X] => (x: X) => (ordx: Ord[X]) ?=> [Y] => (y: Y) => (ordy: Ord[Y]) ?=> true
 
-// type CmpAlias[X] = X => Boolean
-// type CmpNestedAliased = [X: Ord] => X => [Y] => Y => CmpAlias[Y]
+type CmpAlias[X] = X => Boolean
+type CmpNestedAliased = [X: Ord] => X => [Y] => Y => CmpAlias[Y]
 
-// val less11: CmpNestedAliased = [X: Ord] => (x: X) => [Y] => (y: Y) => (y1: Y) => true
-// val less11Explicit: CmpNestedAliased = [X] => (x: X) => (ordx: Ord[X]) ?=> [Y] => (y: Y) => (y1: Y) => true
+val less11: CmpNestedAliased = [X: Ord] => (x: X) => [Y] => (y: Y) => (y1: Y) => true
+val less11Explicit: CmpNestedAliased = [X] => (x: X) => (ordx: Ord[X]) ?=> [Y] => (y: Y) => (y1: Y) => true
 
 val notationalExample: [X: Ord] => X => [Y: Ord] => Y => Int =
   [X] => (x: X) => (ordx: Ord[X]) ?=> [Y] => (y: Y) => (ordy: Ord[Y]) ?=> 1

From 24e3fa0fe7810b1bc5db0560e7ff7f047e504603 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Thu, 14 Nov 2024 14:14:03 +0100
Subject: [PATCH 163/306] More cleanup of poly context bound desugaring

---
 .../src/dotty/tools/dotc/ast/Desugar.scala    | 133 ++++++++++--------
 .../src/dotty/tools/dotc/typer/Typer.scala    |   4 +-
 .../contextbounds-for-poly-functions.scala    |   5 +
 3 files changed, 83 insertions(+), 59 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 768d598987f0..0bf3ba71b84d 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -247,7 +247,7 @@ object desugar {
    *      def f$default$2[T](x: Int) = x + "m"
    */
   private def defDef(meth: DefDef, isPrimaryConstructor: Boolean = false)(using Context): Tree =
-    addDefaultGetters(elimContextBounds(meth, isPrimaryConstructor))
+    addDefaultGetters(elimContextBounds(meth, isPrimaryConstructor).asInstanceOf[DefDef])
 
   /** Drop context bounds in given TypeDef, replacing them with evidence ValDefs that
    *  get added to a buffer.
@@ -309,10 +309,8 @@ object desugar {
       tdef1
   end desugarContextBounds
 
-  private def elimContextBounds(meth: DefDef, isPrimaryConstructor: Boolean)(using Context): DefDef =
-    val DefDef(_, paramss, tpt, rhs) = meth
+  def elimContextBounds(meth: Tree, isPrimaryConstructor: Boolean = false)(using Context): Tree =
     val evidenceParamBuf = mutable.ListBuffer[ValDef]()
-
     var seenContextBounds: Int = 0
     def freshName(unused: Tree) =
       seenContextBounds += 1 // Start at 1 like FreshNameCreator.
@@ -322,7 +320,7 @@ object desugar {
       // parameters of the method since shadowing does not affect
       // implicit resolution in Scala 3.
 
-    val paramssNoContextBounds =
+    def paramssNoContextBounds(paramss: List[ParamClause]): List[ParamClause] =
       val iflag = paramss.lastOption.flatMap(_.headOption) match
         case Some(param) if param.mods.isOneOf(GivenOrImplicit) =>
           param.mods.flags & GivenOrImplicit
@@ -334,16 +332,29 @@ object desugar {
         tparam => desugarContextBounds(tparam, evidenceParamBuf, flags, freshName, paramss)
       }(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
-        )
+    meth match
+      case meth @ DefDef(_, paramss, tpt, rhs) =>
+        val newParamss = paramssNoContextBounds(paramss)
+        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 = newParamss
+              ),
+              evidenceParamBuf.toList
+            )
+      case meth @ PolyFunction(tparams, fun) =>
+        val PolyFunction(tparams: List[untpd.TypeDef] @unchecked, fun) = meth: @unchecked
+        val Function(vparams: List[untpd.ValDef] @unchecked, rhs) = fun: @unchecked
+        val newParamss = paramssNoContextBounds(tparams :: vparams :: Nil)
+        val params = evidenceParamBuf.toList
+        val boundNames = getBoundNames(params, newParamss)
+        val recur = fitEvidenceParams(params, nme.apply, boundNames)
+        val (paramsFst, paramsSnd) = recur(newParamss)
+        functionsOf((paramsFst ++ paramsSnd).filter(_.nonEmpty), rhs)
   end elimContextBounds
 
   def addDefaultGetters(meth: DefDef)(using Context): Tree =
@@ -471,6 +482,55 @@ object desugar {
       case _ =>
         (Nil, tree)
 
+  private def referencesName(vdef: ValDef, names: Set[TermName])(using Context): Boolean =
+    vdef.tpt.existsSubTree:
+      case Ident(name: TermName) => names.contains(name)
+      case _ => false
+
+  /** Fit evidence `params` into the `mparamss` parameter lists */
+  private def fitEvidenceParams(params: List[ValDef], methName: Name, boundNames: Set[TermName])(mparamss: List[ParamClause])(using Context): (List[ParamClause], List[ParamClause]) = mparamss match
+    case ValDefs(mparams) :: _ if mparams.exists(referencesName(_, boundNames)) =>
+      (params :: Nil) -> mparamss
+    case ValDefs(mparams @ (mparam :: _)) :: Nil if mparam.mods.isOneOf(GivenOrImplicit) =>
+      val normParams =
+        if params.head.mods.flags.is(Given) != mparam.mods.flags.is(Given) then
+          params.map: param =>
+            val normFlags = param.mods.flags &~ GivenOrImplicit | (mparam.mods.flags & (GivenOrImplicit))
+            param.withMods(param.mods.withFlags(normFlags))
+              .showing(i"adapted param $result ${result.mods.flags} for ${methName}", Printers.desugar)
+        else params
+      ((normParams ++ mparams) :: Nil) -> Nil
+    case mparams :: mparamss1 =>
+      val (fst, snd) = fitEvidenceParams(params, methName, boundNames)(mparamss1)
+      (mparams :: fst) -> snd
+    case Nil =>
+      Nil -> (params :: Nil)
+
+  /** Create a chain of possibly contextual functions from the parameter lists */
+  private def functionsOf(paramss: List[ParamClause], rhs: Tree)(using Context): Tree = paramss match
+    case Nil => rhs
+    case ValDefs(head @ (fst :: _)) :: rest if fst.mods.isOneOf(GivenOrImplicit) =>
+      val paramTpts = head.map(_.tpt)
+      val paramNames = head.map(_.name)
+      val paramsErased = head.map(_.mods.flags.is(Erased))
+      makeContextualFunction(paramTpts, paramNames, functionsOf(rest, rhs), paramsErased).withSpan(rhs.span)
+    case ValDefs(head) :: rest =>
+      Function(head, functionsOf(rest, rhs))
+    case TypeDefs(head) :: rest =>
+      PolyFunction(head, functionsOf(rest, rhs))
+    case _ =>
+      assert(false, i"unexpected paramss $paramss")
+      EmptyTree
+
+  private def getBoundNames(params: List[ValDef], paramss: List[ParamClause])(using Context): Set[TermName] =
+    var boundNames = params.map(_.name).toSet // all evidence parameter + context bound proxy names
+    for mparams <- paramss; mparam <- mparams do
+      mparam match
+        case tparam: TypeDef if tparam.mods.annotations.exists(WitnessNamesAnnot.unapply(_).isDefined) =>
+          boundNames += tparam.name.toTermName
+        case _ =>
+    boundNames
+
   /**  Add all evidence parameters in `params` as implicit parameters to `meth`.
    *   The position of the added parameters is determined as follows:
    *
@@ -485,48 +545,9 @@ object desugar {
   private def addEvidenceParams(meth: DefDef, params: List[ValDef])(using Context): DefDef =
     if params.isEmpty then return meth
 
-    var boundNames = params.map(_.name).toSet // all evidence parameter + context bound proxy names
-    for mparams <- meth.paramss; mparam <- mparams do
-      mparam match
-        case tparam: TypeDef if tparam.mods.annotations.exists(WitnessNamesAnnot.unapply(_).isDefined) =>
-          boundNames += tparam.name.toTermName
-        case _ =>
+    val boundNames = getBoundNames(params, meth.paramss)
 
-    def referencesBoundName(vdef: ValDef): Boolean =
-      vdef.tpt.existsSubTree:
-        case Ident(name: TermName) => boundNames.contains(name)
-        case _ => false
-
-    def recur(mparamss: List[ParamClause]): (List[ParamClause], List[ParamClause]) = mparamss match
-      case ValDefs(mparams) :: _ if mparams.exists(referencesBoundName) =>
-        (params :: Nil) -> mparamss
-      case ValDefs(mparams @ (mparam :: _)) :: Nil if mparam.mods.isOneOf(GivenOrImplicit) =>
-        val normParams =
-          if params.head.mods.flags.is(Given) != mparam.mods.flags.is(Given) then
-            params.map: param =>
-              val normFlags = param.mods.flags &~ GivenOrImplicit | (mparam.mods.flags & (GivenOrImplicit))
-              param.withMods(param.mods.withFlags(normFlags))
-                .showing(i"adapted param $result ${result.mods.flags} for ${meth.name}", Printers.desugar)
-          else params
-        ((normParams ++ mparams) :: Nil) -> Nil
-      case mparams :: mparamss1 =>
-        val (fst, snd) = recur(mparamss1)
-        (mparams :: fst) -> snd
-      case Nil =>
-        Nil -> (params :: Nil)
-
-    def functionsOf(paramss: List[ParamClause], rhs: Tree): Tree = paramss match
-      case Nil => rhs
-      case ValDefs(head @ (fst :: _)) :: rest if fst.mods.isOneOf(GivenOrImplicit) =>
-        val paramTpts = params.map(_.tpt)
-        val paramNames = params.map(_.name)
-        val paramsErased = params.map(_.mods.flags.is(Erased))
-        makeContextualFunction(paramTpts, paramNames, functionsOf(rest, rhs), paramsErased).withSpan(rhs.span)
-      case ValDefs(head) :: rest =>
-        Function(head, functionsOf(rest, rhs))
-      case head :: _ =>
-        assert(false, i"unexpected type parameters when adding evidence parameters to $meth")
-        EmptyTree
+    val recur = fitEvidenceParams(params, meth.name, boundNames)
 
     if meth.hasAttachment(PolyFunctionApply) then
       meth.removeAttachment(PolyFunctionApply)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index f7610520f61c..bc4981ef11a4 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1920,7 +1920,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   def typedPolyFunction(tree: untpd.PolyFunction, pt: Type)(using Context): Tree =
     val tree1 = desugar.normalizePolyFunction(tree)
     if (ctx.mode is Mode.Type) typed(desugar.makePolyFunctionType(tree1), pt)
-    else typedPolyFunctionValue(tree1, pt)
+    else typedPolyFunctionValue(desugar.elimContextBounds(tree1).asInstanceOf[untpd.PolyFunction], pt)
 
   def typedPolyFunctionValue(tree: untpd.PolyFunction, pt: Type)(using Context): Tree =
     val untpd.PolyFunction(tparams: List[untpd.TypeDef] @unchecked, fun) = tree: @unchecked
@@ -1946,7 +1946,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             untpd.InLambdaTypeTree(isResult = true, (tsyms, vsyms) =>
               mt.resultType.substParams(mt, vsyms.map(_.termRef)).substParams(poly, tsyms.map(_.typeRef)))
           val desugared @ Block(List(defdef), _) = desugar.makeClosure(tparams, inferredVParams, body, resultTpt, tree.span)
-          defdef.putAttachment(desugar.PolyFunctionApply, List.empty)
           typed(desugared, pt)
         else
           val msg =
@@ -1955,7 +1954,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           errorTree(EmptyTree, msg, tree.srcPos)
       case _ =>
         val desugared @ Block(List(defdef), _) = desugar.makeClosure(tparams, vparams, body, untpd.TypeTree(), tree.span)
-        defdef.putAttachment(desugar.PolyFunctionApply, List.empty)
         typed(desugared, pt)
   end typedPolyFunctionValue
 
diff --git a/tests/pos/contextbounds-for-poly-functions.scala b/tests/pos/contextbounds-for-poly-functions.scala
index 6fadcda2b43e..13411a3ad769 100644
--- a/tests/pos/contextbounds-for-poly-functions.scala
+++ b/tests/pos/contextbounds-for-poly-functions.scala
@@ -86,3 +86,8 @@ val namedConstraintRef = [X: {Ord as ord}] => (x: ord.T) => x
 type DependentCmp = [X: {Ord as ord}] => ord.T => Boolean
 type DependentCmp1 = [X: {Ord as ord}] => (ord.T, Int) => ord.T => Boolean
 val dependentCmp: DependentCmp = [X: {Ord as ord}] => (x: ord.T) => true
+val dependentCmp_1: [X: {Ord as ord}] => ord.T => Boolean = [X: {Ord as ord}] => (x: ord.T) => true
+
+val dependentCmp1: DependentCmp1 = [X: {Ord as ord}] => (x: ord.T, y: Int) => (z: ord.T) => true
+val dependentCmp1_1: [X: {Ord as ord}] => (ord.T, Int) => ord.T => Boolean =
+  [X: {Ord as ord}] => (x: ord.T, y: Int) => (z: ord.T) => true

From f292ac54869e9b407a389ea75f891515ad31e07b Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Thu, 14 Nov 2024 16:15:08 +0100
Subject: [PATCH 164/306] Short circuit adding evidence params to poly
 functions, when there are no context bounds

---
 compiler/src/dotty/tools/dotc/ast/Desugar.scala | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 0bf3ba71b84d..e8ebd77b0423 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -351,6 +351,7 @@ object desugar {
         val Function(vparams: List[untpd.ValDef] @unchecked, rhs) = fun: @unchecked
         val newParamss = paramssNoContextBounds(tparams :: vparams :: Nil)
         val params = evidenceParamBuf.toList
+        if params.isEmpty then return meth
         val boundNames = getBoundNames(params, newParamss)
         val recur = fitEvidenceParams(params, nme.apply, boundNames)
         val (paramsFst, paramsSnd) = recur(newParamss)

From 11d4295e68fbb27a38bf56ad1bd13d8f9052c618 Mon Sep 17 00:00:00 2001
From: Jan Chyb <48855024+jchyb@users.noreply.github.com>
Date: Thu, 14 Nov 2024 16:32:05 +0100
Subject: [PATCH 165/306] Replace symbol traversal with tree traversal when
 finding top level experimentals (#21827)

Aims to fix stale symbol errors caused by the symbol traversal after suspending by a macro
---
 .../src/dotty/tools/dotc/typer/Checking.scala | 30 +++++++++----------
 tests/pos-macros/i21802/Macro.scala           | 15 ++++++++++
 tests/pos-macros/i21802/Test.scala            | 13 ++++++++
 3 files changed, 43 insertions(+), 15 deletions(-)
 create mode 100644 tests/pos-macros/i21802/Macro.scala
 create mode 100644 tests/pos-macros/i21802/Test.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
index 761e7cdab37c..1cd531046753 100644
--- a/compiler/src/dotty/tools/dotc/typer/Checking.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -806,20 +806,20 @@ object Checking {
    *
    */
   def checkAndAdaptExperimentalImports(trees: List[Tree])(using Context): Unit =
-    def nonExperimentalTopLevelDefs(pack: Symbol): Iterator[Symbol] =
-      def isNonExperimentalTopLevelDefinition(sym: Symbol) =
-        sym.isDefinedInCurrentRun
-        && sym.source == ctx.compilationUnit.source
-        && !sym.isConstructor // not constructor of package object
-        && !sym.is(Package) && !sym.name.isPackageObjectName
-        && !sym.isExperimental
-
-      pack.info.decls.toList.iterator.flatMap: sym =>
-        if sym.isClass && (sym.is(Package) || sym.isPackageObject) then
-          nonExperimentalTopLevelDefs(sym)
-        else if isNonExperimentalTopLevelDefinition(sym) then
-          sym :: Nil
-        else Nil
+    def nonExperimentalTopLevelDefs(): List[Symbol] =
+      new TreeAccumulator[List[Symbol]] {
+        override def apply(x: List[Symbol], tree: tpd.Tree)(using Context): List[Symbol] =
+          def addIfNotExperimental(sym: Symbol) =
+            if !sym.isExperimental then sym :: x
+            else x
+          tree match {
+            case tpd.PackageDef(_, contents) => apply(x, contents)
+            case typeDef @ tpd.TypeDef(_, temp: Template) if typeDef.symbol.isPackageObject =>
+              apply(x, temp.body)
+            case mdef: tpd.MemberDef => addIfNotExperimental(mdef.symbol)
+            case _ => x
+          }
+      }.apply(Nil, ctx.compilationUnit.tpdTree)
 
     def unitExperimentalLanguageImports =
       def isAllowedImport(sel: untpd.ImportSelector) =
@@ -837,7 +837,7 @@ object Checking {
 
     if ctx.owner.is(Package) || ctx.owner.name.startsWith(str.REPL_SESSION_LINE) then
       def markTopLevelDefsAsExperimental(why: String): Unit =
-        for sym <- nonExperimentalTopLevelDefs(ctx.owner) do
+        for sym <- nonExperimentalTopLevelDefs() do
           sym.addAnnotation(ExperimentalAnnotation(s"Added by $why", sym.span))
 
       unitExperimentalLanguageImports match
diff --git a/tests/pos-macros/i21802/Macro.scala b/tests/pos-macros/i21802/Macro.scala
new file mode 100644
index 000000000000..e2eb1287c727
--- /dev/null
+++ b/tests/pos-macros/i21802/Macro.scala
@@ -0,0 +1,15 @@
+class MetricsGroup[A]
+object MetricsGroup:
+  import scala.quoted.*
+
+  transparent inline final def refine[A]: MetricsGroup[A] =
+    ${ refineImpl[A] }
+
+  private def refineImpl[A](using qctx: Quotes, tpe: Type[A]): Expr[MetricsGroup[A]] =
+    import qctx.reflect.*
+
+    val mt = MethodType(Nil)(_ => Nil, _ => TypeRepr.of[A])
+    val tpe = Refinement(TypeRepr.of[MetricsGroup[A]], "apply", mt).asType
+    tpe match
+      case '[tpe] =>
+        '{ MetricsGroup[A]().asInstanceOf[MetricsGroup[A] & tpe] }
diff --git a/tests/pos-macros/i21802/Test.scala b/tests/pos-macros/i21802/Test.scala
new file mode 100644
index 000000000000..70063653c43c
--- /dev/null
+++ b/tests/pos-macros/i21802/Test.scala
@@ -0,0 +1,13 @@
+//> using options -experimental -Ydebug
+
+class ProbeFailedException(cause: Exception) extends Exception(cause)
+trait Probing:
+  self: Metrics =>
+    val probeFailureCounter: MetricsGroup[Counter] =
+      counters("ustats_probe_failures_count").labelled
+
+
+trait Counter
+class Metrics:
+  class counters(name: String):
+    transparent inline final def labelled: MetricsGroup[Counter] = MetricsGroup.refine[Counter]

From 6a7d5d34719ec3904c3cbf5d749fee1881e8bcf6 Mon Sep 17 00:00:00 2001
From: Jan Chyb <jan.chyb.99@gmail.com>
Date: Tue, 12 Nov 2024 12:16:19 +0100
Subject: [PATCH 166/306] Bring back the fix for scaladoc TastyInspector
 regressions

Brings back the previosuly reverted commit with an added
fix for the test.
---
 .../sbt-dotty/scaladoc-regressions/build.sbt  |  9 ++++
 .../i18231/src/main/scala/main.scala          |  4 ++
 .../i20476/src/main/scala/main.scala          |  5 +++
 .../scaladoc-regressions/project/plugins.sbt  |  1 +
 sbt-test/sbt-dotty/scaladoc-regressions/test  |  2 +
 .../tools/scaladoc/tasty/TastyParser.scala    |  4 +-
 .../tasty/inspector/TastyInspector.scala      | 43 ++++++++++++++-----
 ...ernalLocationProviderIntegrationTest.scala |  5 ++-
 .../no-link-warnings/LinkWarningTest.scala    |  3 +-
 9 files changed, 60 insertions(+), 16 deletions(-)
 create mode 100644 sbt-test/sbt-dotty/scaladoc-regressions/build.sbt
 create mode 100644 sbt-test/sbt-dotty/scaladoc-regressions/i18231/src/main/scala/main.scala
 create mode 100644 sbt-test/sbt-dotty/scaladoc-regressions/i20476/src/main/scala/main.scala
 create mode 100644 sbt-test/sbt-dotty/scaladoc-regressions/project/plugins.sbt
 create mode 100644 sbt-test/sbt-dotty/scaladoc-regressions/test

diff --git a/sbt-test/sbt-dotty/scaladoc-regressions/build.sbt b/sbt-test/sbt-dotty/scaladoc-regressions/build.sbt
new file mode 100644
index 000000000000..bfdadb5ee038
--- /dev/null
+++ b/sbt-test/sbt-dotty/scaladoc-regressions/build.sbt
@@ -0,0 +1,9 @@
+ThisBuild / scalaVersion := sys.props("plugin.scalaVersion")
+
+lazy val i20476 = project
+  .in(file("i20476"))
+  .enablePlugins(ScalaJSPlugin)
+
+lazy val i18231 = project
+  .in(file("i18231"))
+  .settings(scalacOptions += "-release:8")
diff --git a/sbt-test/sbt-dotty/scaladoc-regressions/i18231/src/main/scala/main.scala b/sbt-test/sbt-dotty/scaladoc-regressions/i18231/src/main/scala/main.scala
new file mode 100644
index 000000000000..82788aa829f0
--- /dev/null
+++ b/sbt-test/sbt-dotty/scaladoc-regressions/i18231/src/main/scala/main.scala
@@ -0,0 +1,4 @@
+object Foo {
+    @Deprecated
+    def foo(): Unit = ???
+}
diff --git a/sbt-test/sbt-dotty/scaladoc-regressions/i20476/src/main/scala/main.scala b/sbt-test/sbt-dotty/scaladoc-regressions/i20476/src/main/scala/main.scala
new file mode 100644
index 000000000000..31eb78c816cd
--- /dev/null
+++ b/sbt-test/sbt-dotty/scaladoc-regressions/i20476/src/main/scala/main.scala
@@ -0,0 +1,5 @@
+package demo
+
+import scala.scalajs.js
+
+def bar: js.Promise[Int] = js.Promise.resolve(()).`then`(_ => 1)
diff --git a/sbt-test/sbt-dotty/scaladoc-regressions/project/plugins.sbt b/sbt-test/sbt-dotty/scaladoc-regressions/project/plugins.sbt
new file mode 100644
index 000000000000..b9ebfd07bf1f
--- /dev/null
+++ b/sbt-test/sbt-dotty/scaladoc-regressions/project/plugins.sbt
@@ -0,0 +1 @@
+addSbtPlugin("org.scala-js" % "sbt-scalajs" % sys.props("plugin.scalaJSVersion"))
diff --git a/sbt-test/sbt-dotty/scaladoc-regressions/test b/sbt-test/sbt-dotty/scaladoc-regressions/test
new file mode 100644
index 000000000000..816c0be96141
--- /dev/null
+++ b/sbt-test/sbt-dotty/scaladoc-regressions/test
@@ -0,0 +1,2 @@
+> i18231/doc
+> i20476/doc
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/TastyParser.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/TastyParser.scala
index f55451fdc636..1a8337e0c6b7 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/TastyParser.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/TastyParser.scala
@@ -5,7 +5,7 @@ package tasty
 import java.util.regex.Pattern
 
 import scala.util.{Try, Success, Failure}
-import scala.tasty.inspector.{TastyInspector, Inspector, Tasty}
+import scala.tasty.inspector.{ScaladocInternalTastyInspector, Inspector, Tasty}
 import scala.quoted._
 
 import dotty.tools.dotc
@@ -160,7 +160,7 @@ object ScaladocTastyInspector:
       report.error("File extension is not `tasty` or `jar`: " + invalidPath)
 
     if tastyPaths.nonEmpty then
-      TastyInspector.inspectAllTastyFiles(tastyPaths, jarPaths, classpath)(inspector)
+      ScaladocInternalTastyInspector.inspectAllTastyFilesInContext(tastyPaths, jarPaths, classpath)(inspector)(using ctx.compilerContext)
 
     val all = inspector.topLevels.result()
     all.groupBy(_._1).map { case (pckName, members) =>
diff --git a/scaladoc/src/scala/tasty/inspector/TastyInspector.scala b/scaladoc/src/scala/tasty/inspector/TastyInspector.scala
index 906578c9d405..190be6a588a1 100644
--- a/scaladoc/src/scala/tasty/inspector/TastyInspector.scala
+++ b/scaladoc/src/scala/tasty/inspector/TastyInspector.scala
@@ -1,5 +1,7 @@
-// Copy of tasty-inspector/src/scala/tasty/inspector/TastyInspector.scala
+// Renamed copy of tasty-inspector/src/scala/tasty/inspector/TastyInspector.scala
 // FIXME remove this copy of the file
+// Since copying, an inspectAllTastyFilesInContext method was added for scaladoc only
+// to fix regressions introduced by the switch from old to a new TastyInspector
 
 package scala.tasty.inspector
 
@@ -21,7 +23,7 @@ import dotty.tools.dotc.report
 
 import java.io.File.pathSeparator
 
-object TastyInspector:
+object ScaladocInternalTastyInspector:
 
   /** Load and process TASTy files using TASTy reflect
    *
@@ -41,6 +43,32 @@ object TastyInspector:
   def inspectTastyFilesInJar(jar: String)(inspector: Inspector): Boolean =
     inspectAllTastyFiles(Nil, List(jar), Nil)(inspector)
 
+  private def checkFiles(tastyFiles: List[String], jars: List[String]): Unit =
+    def checkFile(fileName: String, ext: String): Unit =
+      val file = dotty.tools.io.Path(fileName)
+      if !file.ext.toLowerCase.equalsIgnoreCase(ext) then
+        throw new IllegalArgumentException(s"File extension is not `.$ext`: $file")
+      else if !file.exists then
+        throw new IllegalArgumentException(s"File not found: ${file.toAbsolute}")
+    tastyFiles.foreach(checkFile(_, "tasty"))
+    jars.foreach(checkFile(_, "jar"))
+
+  /**
+  * Added for Scaladoc-only.
+  * Meant to fix regressions introduces by the switch from old to new TastyInspector:
+  *  https://github.com/scala/scala3/issues/18231
+  *  https://github.com/scala/scala3/issues/20476
+  * Stable TastyInspector API does not support passing compiler context.
+  */
+  def inspectAllTastyFilesInContext(tastyFiles: List[String], jars: List[String], dependenciesClasspath: List[String])(inspector: Inspector)(using Context): Boolean =
+    checkFiles(tastyFiles, jars)
+    val classes = tastyFiles ::: jars
+    classes match
+      case Nil => true
+      case _ =>
+        val reporter = inspectorDriver(inspector).process(inspectorArgs(dependenciesClasspath, classes), summon[Context])
+        !reporter.hasErrors
+
   /** Load and process TASTy files using TASTy reflect
    *
    *  @param tastyFiles List of paths of `.tasty` files
@@ -50,14 +78,7 @@ object TastyInspector:
    *  @return boolean value indicating whether the process succeeded
    */
   def inspectAllTastyFiles(tastyFiles: List[String], jars: List[String], dependenciesClasspath: List[String])(inspector: Inspector): Boolean =
-    def checkFile(fileName: String, ext: String): Unit =
-      val file = dotty.tools.io.Path(fileName)
-      if !file.ext.toLowerCase.equalsIgnoreCase(ext) then
-        throw new IllegalArgumentException(s"File extension is not `.$ext`: $file")
-      else if !file.exists then
-        throw new IllegalArgumentException(s"File not found: ${file.toAbsolute}")
-    tastyFiles.foreach(checkFile(_, "tasty"))
-    jars.foreach(checkFile(_, "jar"))
+    checkFiles(tastyFiles, jars)
     val files = tastyFiles ::: jars
     inspectFiles(dependenciesClasspath, files)(inspector)
 
@@ -124,4 +145,4 @@ object TastyInspector:
   end inspectFiles
 
 
-end TastyInspector
+end ScaladocInternalTastyInspector
diff --git a/scaladoc/test/dotty/tools/scaladoc/ExternalLocationProviderIntegrationTest.scala b/scaladoc/test/dotty/tools/scaladoc/ExternalLocationProviderIntegrationTest.scala
index a63f699c4c2f..ec39fb5ce16b 100644
--- a/scaladoc/test/dotty/tools/scaladoc/ExternalLocationProviderIntegrationTest.scala
+++ b/scaladoc/test/dotty/tools/scaladoc/ExternalLocationProviderIntegrationTest.scala
@@ -57,8 +57,9 @@ class Scaladoc3ExternalLocationProviderIntegrationTest extends ExternalLocationP
 
 def getScalaLibraryPath: String = {
   val classpath: List[String] = System.getProperty("java.class.path").split(java.io.File.pathSeparatorChar).toList
-  val stdlib = classpath.find(_.contains("scala-library-2")).getOrElse("foobarbazz") // If we don't find the scala 2 library, the test will fail
-  new java.io.File(stdlib).getCanonicalPath() // canonicalize for case-insensitive file systems
+  // For an unclear reason, depending on if we pass the compiler context onto the tasty inspector
+  // the scala-2-library path needs to have its characters case fixed with new java.io.File(stdlib).getCanonicalPath()
+  classpath.find(_.contains("scala-library-2")).getOrElse("foobarbazz") // If we don't find the scala 2 library, the test will fail
 }
 
 class Scaladoc2LegacyExternalLocationProviderIntegrationTest extends LegacyExternalLocationProviderIntegrationTest(
diff --git a/scaladoc/test/dotty/tools/scaladoc/no-link-warnings/LinkWarningTest.scala b/scaladoc/test/dotty/tools/scaladoc/no-link-warnings/LinkWarningTest.scala
index 1d140315cc10..bcaee696b65c 100644
--- a/scaladoc/test/dotty/tools/scaladoc/no-link-warnings/LinkWarningTest.scala
+++ b/scaladoc/test/dotty/tools/scaladoc/no-link-warnings/LinkWarningTest.scala
@@ -14,6 +14,7 @@ class LinkWarningsTest extends ScaladocTest("noLinkWarnings"):
 
   override def runTest = afterRendering {
     val diagnostics = summon[DocContext].compilerContext.reportedDiagnostics
-    assertEquals("There should be exactly one warning", 1, diagnostics.warningMsgs.size)
+    val filteredWarnings = diagnostics.warningMsgs.filter(_ != "1 warning found")
+    assertEquals("There should be exactly one warning", 1, filteredWarnings.size)
     assertNoErrors(diagnostics)
   }

From 26ecda540b93fbe1fc7be030559a78dd2db364f2 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Thu, 14 Nov 2024 22:11:20 +0000
Subject: [PATCH 167/306] Drop phase.isTyper use in isLegalPrefix/asf

Note that "asSeenFrom" (aka asf) is used by SymDenotation#findMember,
which is used by TypeComparer's "hasMatchingMember", as a part of
"compareRefinedSlow".

Previously (using the minimisation in i17222.8.scala) `summonOne` is
inlined during the "inlining" phase, while "summonInline" is inlined
during typing.  The result is that during inlining we fail to find
`Reader[BC, Int]` because we incorrectly consider `A{type F = Int}` as
stable.
---
 .../dotty/tools/dotc/core/TypeComparer.scala  |  5 +-
 .../src/dotty/tools/dotc/core/TypeOps.scala   |  2 +-
 .../src/dotty/tools/dotc/core/Types.scala     | 29 ++++----
 .../dotty/tools/dotc/transform/Recheck.scala  |  4 +-
 .../test/dotc/pos-test-pickling.blacklist     |  1 +
 tests/neg/6314-6.check                        |  4 +-
 tests/neg/i6225.scala                         |  2 +-
 tests/pos/i17222.2.scala                      | 30 ++++++++
 tests/pos/i17222.3.scala                      | 39 ++++++++++
 tests/pos/i17222.4.scala                      | 71 +++++++++++++++++++
 tests/pos/i17222.5.scala                      | 26 +++++++
 tests/pos/i17222.8.scala                      | 18 +++++
 tests/pos/i17222.scala                        | 33 +++++++++
 13 files changed, 240 insertions(+), 24 deletions(-)
 create mode 100644 tests/pos/i17222.2.scala
 create mode 100644 tests/pos/i17222.3.scala
 create mode 100644 tests/pos/i17222.4.scala
 create mode 100644 tests/pos/i17222.5.scala
 create mode 100644 tests/pos/i17222.8.scala
 create mode 100644 tests/pos/i17222.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 17d427513e58..9cef4148747e 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -369,7 +369,8 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         }
         compareWild
       case tp2: LazyRef =>
-        isBottom(tp1) || !tp2.evaluating && recur(tp1, tp2.ref)
+        isBottom(tp1)
+        || !tp2.evaluating && recur(tp1, tp2.ref)
       case CapturingType(_, _) =>
         secondTry
       case tp2: AnnotatedType if !tp2.isRefining =>
@@ -489,7 +490,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         // 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)
+        tp2.isAny
         || !tp1.evaluating && recur(tp1.ref, tp2)
       case AndType(tp11, tp12) =>
         if tp11.stripTypeVar eq tp12.stripTypeVar then recur(tp11, tp2)
diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
index 2403a6e22bc6..c27b3c3978d7 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -124,7 +124,7 @@ object TypeOps:
   }
 
   def isLegalPrefix(pre: Type)(using Context): Boolean =
-    pre.isStable || !ctx.phase.isTyper
+    pre.isStable
 
   /** Implementation of Types#simplified */
   def simplify(tp: Type, theMap: SimplifyMap | Null)(using Context): Type = {
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index d8a4453325f2..2d53150c72cc 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -99,12 +99,8 @@ object Types extends TypeUtils {
 // ----- Tests -----------------------------------------------------
 
 //    // debug only: a unique identifier for a type
-//    val uniqId = {
-//      nextId = nextId + 1
-//      if (nextId == 19555)
-//        println("foo")
-//      nextId
-//    }
+//    val uniqId = { nextId = nextId + 1; nextId }
+//    if uniqId == 19555 then trace.dumpStack()
 
     /** A cache indicating whether the type was still provisional, last time we checked */
     @sharable private var mightBeProvisional = true
@@ -5577,24 +5573,25 @@ object Types extends TypeUtils {
     }
 
     def & (that: TypeBounds)(using Context): TypeBounds =
+      val lo1 = this.lo.stripLazyRef
+      val lo2 = that.lo.stripLazyRef
+      val hi1 = this.hi.stripLazyRef
+      val hi2 = that.hi.stripLazyRef
+
       // 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
+      if hi1.containsFromJavaObject && (hi1 frozen_<:< hi2) && (lo2 frozen_<:< lo1) 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
+      else if hi2.containsFromJavaObject && (hi2 frozen_<:< hi1) && (lo1 frozen_<:< lo2) 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)
+      else if (lo1 frozen_<:< lo2) && (hi2 frozen_<:< hi1) then that
+      else if (lo2 frozen_<:< lo1) && (hi1 frozen_<:< hi2) then this
+      else TypeBounds(lo1 | lo2, hi1 & hi2)
 
     def | (that: TypeBounds)(using Context): TypeBounds =
       if ((this.lo frozen_<:< that.lo) && (that.hi frozen_<:< this.hi)) this
@@ -5603,7 +5600,7 @@ object Types extends TypeUtils {
 
     override def & (that: Type)(using Context): Type = that match {
       case that: TypeBounds => this & that
-      case _ => super.& (that)
+      case _ => super.&(that)
     }
 
     override def | (that: Type)(using Context): Type = that match {
diff --git a/compiler/src/dotty/tools/dotc/transform/Recheck.scala b/compiler/src/dotty/tools/dotc/transform/Recheck.scala
index 8df9e5966920..be1d9d8bee54 100644
--- a/compiler/src/dotty/tools/dotc/transform/Recheck.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Recheck.scala
@@ -217,10 +217,10 @@ abstract class Recheck extends Phase, SymTransformer:
         sharpen: Denotation => Denotation)(using Context): Type =
       if name.is(OuterSelectName) then tree.tpe
       else
-        //val pre = ta.maybeSkolemizePrefix(qualType, name)
+        val pre = ta.maybeSkolemizePrefix(qualType, name)
         val mbr =
           sharpen(
-            qualType.findMember(name, qualType,
+            qualType.findMember(name, pre,
               excluded = if tree.symbol.is(Private) then EmptyFlags else Private
           )).suchThat(tree.symbol == _)
         val newType = tree.tpe match
diff --git a/compiler/test/dotc/pos-test-pickling.blacklist b/compiler/test/dotc/pos-test-pickling.blacklist
index 032b53150e49..ebdd414ea7f2 100644
--- a/compiler/test/dotc/pos-test-pickling.blacklist
+++ b/compiler/test/dotc/pos-test-pickling.blacklist
@@ -23,6 +23,7 @@ t5031_2.scala
 i16997.scala
 i7414.scala
 i17588.scala
+i8300.scala
 i9804.scala
 i13433.scala
 i16649-irrefutable.scala
diff --git a/tests/neg/6314-6.check b/tests/neg/6314-6.check
index 7d6bd182173d..df988f1db9dd 100644
--- a/tests/neg/6314-6.check
+++ b/tests/neg/6314-6.check
@@ -4,7 +4,7 @@
    |object creation impossible, since def apply(fa: String): Int in trait XX in object Test3 is not defined 
    |(Note that
    | parameter String in def apply(fa: String): Int in trait XX in object Test3 does not match
-   | parameter Test3.Bar[X & Object with Test3.YY {...}#Foo] in def apply(fa: Test3.Bar[X & YY.this.Foo]): Test3.Bar[Y & YY.this.Foo] in trait YY in object Test3
+   | parameter Test3.Bar[X & (X & Y)] in def apply(fa: Test3.Bar[X & YY.this.Foo]): Test3.Bar[Y & YY.this.Foo] in trait YY in object Test3
    | )
 -- Error: tests/neg/6314-6.scala:52:3 ----------------------------------------------------------------------------------
 52 |  (new YY {}).boom // error: object creation impossible
@@ -12,5 +12,5 @@
    |object creation impossible, since def apply(fa: String): Int in trait XX in object Test4 is not defined 
    |(Note that
    | parameter String in def apply(fa: String): Int in trait XX in object Test4 does not match
-   | parameter Test4.Bar[X & Object with Test4.YY {...}#FooAlias] in def apply(fa: Test4.Bar[X & YY.this.FooAlias]): Test4.Bar[Y & YY.this.FooAlias] in trait YY in object Test4
+   | parameter Test4.Bar[X & (X & Y)] in def apply(fa: Test4.Bar[X & YY.this.FooAlias]): Test4.Bar[Y & YY.this.FooAlias] in trait YY in object Test4
    | )
diff --git a/tests/neg/i6225.scala b/tests/neg/i6225.scala
index 148a484fd0f1..bb936c9a79b1 100644
--- a/tests/neg/i6225.scala
+++ b/tests/neg/i6225.scala
@@ -1,4 +1,4 @@
-object O1 {
+object O1 { // error: cannot be instantiated
   type A[X] = X
   opaque type T = A // error: opaque type alias must be fully applied
 }
diff --git a/tests/pos/i17222.2.scala b/tests/pos/i17222.2.scala
new file mode 100644
index 000000000000..34db494750c4
--- /dev/null
+++ b/tests/pos/i17222.2.scala
@@ -0,0 +1,30 @@
+import scala.compiletime.*
+
+trait Reader[-In, Out]
+
+trait A:
+  type T
+  type F[X]
+  type Q = F[T]
+
+object Reader:
+
+  given [X]: Reader[A { type Q = X }, X] with {}
+
+object Test:
+
+  trait B[X] extends A:
+    type T = X
+
+  trait C extends A:
+    type F[X] = X
+
+  trait D[X] extends B[X] with C
+
+  val d = new D[Int] {}
+  val bc = new B[Int] with C
+
+  summonAll[(Reader[d.type, Int], Reader[d.type, Int])] // works
+  summonAll[(Reader[bc.type, Int], Reader[bc.type, Int])] // error
+  summonInline[Reader[d.type, Int]] // works
+  summonInline[Reader[bc.type, Int]] // works??
diff --git a/tests/pos/i17222.3.scala b/tests/pos/i17222.3.scala
new file mode 100644
index 000000000000..7ca85f65278f
--- /dev/null
+++ b/tests/pos/i17222.3.scala
@@ -0,0 +1,39 @@
+import scala.compiletime.*
+
+trait Reader[-In, Out]
+
+trait A:
+  type T
+  type F[X]
+  type Q = F[T]
+
+object Reader:
+
+  given [X]: Reader[A { type Q = X }, X] with {}
+
+object Test:
+
+  trait B[X] extends A:
+    type T = X
+
+  trait C extends A:
+    type F[X] = X
+
+  trait D[X] extends B[X] with C
+
+  val d = new D[Int] {}
+  val bc = new B[Int] with C
+
+  case class Box[T](value: T)
+
+  /** compiletime.summonAll, but with one case */
+  inline def summonOne[T <: Box[?]]: T =
+    val res =
+      inline erasedValue[T] match
+        case _: Box[t] => summonInline[t]
+      end match
+    Box(res).asInstanceOf[T]
+  end summonOne
+
+  summonOne[Box[Reader[d.type, Int]]] // works
+  summonOne[Box[Reader[bc.type, Int]]] // errors
diff --git a/tests/pos/i17222.4.scala b/tests/pos/i17222.4.scala
new file mode 100644
index 000000000000..209425d47915
--- /dev/null
+++ b/tests/pos/i17222.4.scala
@@ -0,0 +1,71 @@
+import scala.compiletime.*
+
+trait Reader[-In, Out]
+
+trait A:
+  type T
+  type F[X]
+  type Q = F[T]
+
+given [X]: Reader[A { type Q = X }, X] with {}
+
+case class Box[T](x: T)
+
+/** compiletime.summonAll, but with one case */
+inline def summonOne[T]: T =
+  val res =
+    inline erasedValue[T] match
+      case _: Box[t] => summonInline[t]
+    end match
+  Box(res).asInstanceOf[T]
+end summonOne
+
+
+@main def main =
+
+
+  trait B[X] extends A:
+    type T = X
+
+  trait C extends A:
+    type F[X] = X
+
+
+  val bc = new B[Int] with C
+
+  summonOne[Box[Reader[bc.type, Int]]] // errors
+
+
+  val bc2: A { type Q = Int } = new B[Int] with C
+
+  summonOne[Box[Reader[bc2.type, Int]]] // works
+
+
+  object BC extends B[Int] with C
+
+  summonOne[Box[Reader[BC.type, Int]]] // works
+
+
+  val a = new A:
+    type T = Int
+    type F[X] = X
+
+  summonOne[Box[Reader[a.type, Int]]] // works
+
+
+  val b = new B[Int]:
+    type F[X] = X
+
+  summonOne[Box[Reader[b.type, Int]]] // works
+
+
+  val ac = new A with C:
+    type T = Int
+
+  summonOne[Box[Reader[ac.type, Int]]] // works
+
+
+  trait D[X] extends B[X] with C
+  val d = new D[Int] {}
+
+  summonOne[Box[Reader[d.type, Int]]] // works
diff --git a/tests/pos/i17222.5.scala b/tests/pos/i17222.5.scala
new file mode 100644
index 000000000000..dc608e94235c
--- /dev/null
+++ b/tests/pos/i17222.5.scala
@@ -0,0 +1,26 @@
+import scala.compiletime.*
+
+trait Reader[-In, Out]
+
+trait A:
+  type T
+  type F[X]
+  type Q = F[T]
+
+given [X]: Reader[A { type Q = X }, X] with {}
+
+case class Box[T](x: T)
+
+inline def summonOne[T]: T =
+  summonInline[T]
+end summonOne
+
+@main def main =
+  trait B[X] extends A:
+    type T = X
+  trait C extends A:
+    type F[X] = X
+
+  val bc = new B[Int] with C
+  summonInline[Reader[bc.type, Int]] // (I) Works
+  summonOne[Reader[bc.type, Int]] // (II) Errors
diff --git a/tests/pos/i17222.8.scala b/tests/pos/i17222.8.scala
new file mode 100644
index 000000000000..a415a78e0703
--- /dev/null
+++ b/tests/pos/i17222.8.scala
@@ -0,0 +1,18 @@
+import scala.compiletime.*
+
+trait A:
+  type F
+  type Q = F
+
+trait Reader[-In, Out]
+object Reader:
+  given [X]: Reader[A { type Q = X }, X] with {}
+
+class Test:
+  //type BC = A { type F = Int } & A // ok
+  type BC = A & A { type F = Int } // fail, also ok when manually de-aliased
+
+  inline def summonOne: Unit = summonInline[Reader[BC, Int]]
+
+  def t1(): Unit = summonInline[Reader[BC, Int]] // ok
+  def t2(): Unit = summonOne // error
diff --git a/tests/pos/i17222.scala b/tests/pos/i17222.scala
new file mode 100644
index 000000000000..2af9fc2861a8
--- /dev/null
+++ b/tests/pos/i17222.scala
@@ -0,0 +1,33 @@
+import scala.deriving.Mirror
+import scala.compiletime.*
+
+trait Reader[-In, Out]
+
+trait A:
+  type T
+  type F[X]
+  type Q = F[T]
+
+object Reader:
+
+  given [X]: Reader[A { type Q = X }, X] with {}
+
+  type Map2[Tup1 <: Tuple, Tup2 <: Tuple, F[_, _]] <: Tuple = (Tup1, Tup2) match
+    case (h1 *: t1, h2 *: t2) => F[h1, h2] *: Map2[t1, t2, F]
+    case (EmptyTuple, EmptyTuple) => EmptyTuple
+
+  inline given productReader[In <: Product, Out <: Product](using mi: Mirror.ProductOf[In])(using mo: Mirror.ProductOf[Out]): Reader[In, Out] =
+    summonAll[Map2[mi.MirroredElemTypes, mo.MirroredElemTypes, Reader]]
+    ???
+
+object Test:
+
+  trait B[X] extends A:
+    type T = X
+
+  trait C extends A:
+    type F[X] = X
+
+  val bc = new B[Int] with C
+
+  summon[Reader[(bc.type, bc.type), (Int, Int)]]    // fails

From f9db9fa0c963de738b39d8230cd30053db671f14 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Fri, 15 Nov 2024 08:35:03 +0100
Subject: [PATCH 168/306] Add a run test for poly context bounds; cleanup typer
 changes

---
 .../src/dotty/tools/dotc/ast/Desugar.scala    |  1 -
 .../src/dotty/tools/dotc/typer/Typer.scala    | 12 ++++----
 .../contextbounds-for-poly-functions.check    |  6 ++++
 .../contextbounds-for-poly-functions.scala    | 30 +++++++++++++++++++
 4 files changed, 42 insertions(+), 7 deletions(-)
 create mode 100644 tests/run/contextbounds-for-poly-functions.check
 create mode 100644 tests/run/contextbounds-for-poly-functions.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index e8ebd77b0423..6e54dee51c89 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -22,7 +22,6 @@ import parsing.Parsers
 
 import scala.annotation.internal.sharable
 import scala.annotation.threadUnsafe
-import dotty.tools.dotc.quoted.QuoteUtils.treeOwner
 
 object desugar {
   import untpd.*
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index bc4981ef11a4..d9b29e8c5f17 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1945,7 +1945,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           val resultTpt =
             untpd.InLambdaTypeTree(isResult = true, (tsyms, vsyms) =>
               mt.resultType.substParams(mt, vsyms.map(_.termRef)).substParams(poly, tsyms.map(_.typeRef)))
-          val desugared @ Block(List(defdef), _) = desugar.makeClosure(tparams, inferredVParams, body, resultTpt, tree.span)
+          val desugared = desugar.makeClosure(tparams, inferredVParams, body, resultTpt, tree.span)
           typed(desugared, pt)
         else
           val msg =
@@ -1953,7 +1953,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                  |Expected type should be a polymorphic function with the same number of type and value parameters."""
           errorTree(EmptyTree, msg, tree.srcPos)
       case _ =>
-        val desugared @ Block(List(defdef), _) = desugar.makeClosure(tparams, vparams, body, untpd.TypeTree(), tree.span)
+        val desugared = desugar.makeClosure(tparams, vparams, body, untpd.TypeTree(), tree.span)
         typed(desugared, pt)
   end typedPolyFunctionValue
 
@@ -3581,17 +3581,17 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
               case xtree => typedUnnamed(xtree)
 
           val unsimplifiedType = result.tpe
-          val result1 = simplify(result, pt, locked)
-          result1.tpe.stripTypeVar match
+          simplify(result, pt, locked)
+          result.tpe.stripTypeVar match
             case e: ErrorType if !unsimplifiedType.isErroneous => errorTree(xtree, e.msg, xtree.srcPos)
-            case _ => result1
+            case _ => result
         catch case ex: TypeError =>
           handleTypeError(ex)
      }
   }
 
   /** Interpolate and simplify the type of the given tree. */
-  protected def simplify(tree: Tree, pt: Type, locked: TypeVars)(using Context): 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
diff --git a/tests/run/contextbounds-for-poly-functions.check b/tests/run/contextbounds-for-poly-functions.check
new file mode 100644
index 000000000000..2e7f62a3914f
--- /dev/null
+++ b/tests/run/contextbounds-for-poly-functions.check
@@ -0,0 +1,6 @@
+42
+a string
+Kate is 27 years old
+42 and a string
+a string and Kate is 27 years old
+Kate is 27 years old and 42
diff --git a/tests/run/contextbounds-for-poly-functions.scala b/tests/run/contextbounds-for-poly-functions.scala
new file mode 100644
index 000000000000..dcc974fce198
--- /dev/null
+++ b/tests/run/contextbounds-for-poly-functions.scala
@@ -0,0 +1,30 @@
+import scala.language.experimental.modularity
+import scala.language.future
+
+trait Show[X]:
+  def show(x: X): String
+
+given Show[Int] with
+  def show(x: Int) = x.toString
+
+given Show[String] with
+  def show(x: String) = x
+
+case class Person(name: String, age: Int)
+
+given Show[Person] with
+  def show(x: Person) = s"${x.name} is ${x.age} years old"
+
+type Shower = [X: Show] => X => String
+val shower: Shower = [X: {Show as show}] => (x: X) => show.show(x)
+
+type DoubleShower = [X: Show] => X => [Y: Show] => Y => String
+val doubleShower: DoubleShower = [X: {Show as show1}] => (x: X) => [Y: {Show as show2}] => (y: Y) => s"${show1.show(x)} and ${show2.show(y)}"
+
+object Test extends App:
+  println(shower(42))
+  println(shower("a string"))
+  println(shower(Person("Kate", 27)))
+  println(doubleShower(42)("a string"))
+  println(doubleShower("a string")(Person("Kate", 27)))
+  println(doubleShower(Person("Kate", 27))(42))

From 7b4597fea9c5d409e769d3ce8fe22a26028eb7c9 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Fri, 15 Nov 2024 09:59:27 +0000
Subject: [PATCH 169/306] Remove tests/pos-with-compiler-cc

---
 .../BootstrappedOnlyCompilationTests.scala    |    7 -
 .../backend/ScalaPrimitivesOps.scala          |  232 -
 .../backend/WorklistAlgorithm.scala           |   57 -
 .../backend/jvm/AsmUtils.scala                |   65 -
 .../backend/jvm/BCodeAsmCommon.scala          |  158 -
 .../backend/jvm/BCodeBodyBuilder.scala        | 1776 -----
 .../backend/jvm/BCodeHelpers.scala            |  960 ---
 .../backend/jvm/BCodeIdiomatic.scala          |  727 --
 .../backend/jvm/BCodeSkelBuilder.scala        |  908 ---
 .../backend/jvm/BCodeSyncAndTry.scala         |  426 --
 .../backend/jvm/BTypes.scala                  |  864 ---
 .../backend/jvm/BTypesFromSymbols.scala       |  348 -
 .../backend/jvm/BytecodeWriters.scala         |  147 -
 .../backend/jvm/ClassNode1.java               |   39 -
 .../backend/jvm/CollectSuperCalls.scala       |   48 -
 .../backend/jvm/CoreBTypes.scala              |  294 -
 .../backend/jvm/DottyBackendInterface.scala   |  204 -
 .../backend/jvm/GenBCode.scala                |  672 --
 .../backend/jvm/GenBCodeOps.scala             |   16 -
 .../backend/jvm/GenericSignatureVisitor.scala |  326 -
 .../backend/jvm/LabelNode1.java               |   31 -
 .../backend/jvm/MethodNode1.java              |   47 -
 .../backend/jvm/Primitives.scala              |  191 -
 .../backend/jvm/scalaPrimitives.scala         |  412 --
 .../backend/sjs/GenSJSIR.scala                |   23 -
 .../backend/sjs/JSCodeGen.scala               | 4897 -------------
 .../backend/sjs/JSDefinitions.scala           |  340 -
 .../backend/sjs/JSEncoding.scala              |  428 --
 .../backend/sjs/JSExportsGen.scala            | 1025 ---
 .../backend/sjs/JSPositions.scala             |  102 -
 .../backend/sjs/JSPrimitives.scala            |  150 -
 .../backend/sjs/ScopedVar.scala               |   38 -
 tests/pos-with-compiler-cc/dotc/Bench.scala   |   64 -
 .../dotc/CompilationUnit.scala                |  167 -
 .../pos-with-compiler-cc/dotc/Compiler.scala  |  171 -
 tests/pos-with-compiler-cc/dotc/Driver.scala  |  207 -
 tests/pos-with-compiler-cc/dotc/Main.scala    |    5 -
 .../dotc/MissingCoreLibraryException.scala    |    9 -
 .../pos-with-compiler-cc/dotc/Resident.scala  |   61 -
 tests/pos-with-compiler-cc/dotc/Run.scala     |  404 --
 .../dotc/ScalacCommand.scala                  |    9 -
 .../dotc/ast/CheckTrees.scala.disabled        |  258 -
 .../dotc/ast/Desugar.scala                    | 1979 -----
 .../dotc/ast/DesugarEnums.scala               |  310 -
 .../dotc/ast/MainProxies.scala                |  449 --
 .../dotc/ast/NavigateAST.scala                |  129 -
 .../dotc/ast/Positioned.scala                 |  246 -
 .../dotc/ast/TreeInfo.scala                   | 1070 ---
 .../dotc/ast/TreeMapWithImplicits.scala       |   82 -
 .../dotc/ast/TreeTypeMap.scala                |  232 -
 .../pos-with-compiler-cc/dotc/ast/Trees.scala | 1787 -----
 tests/pos-with-compiler-cc/dotc/ast/tpd.scala | 1546 ----
 .../pos-with-compiler-cc/dotc/ast/untpd.scala |  829 ---
 .../dotc/cc/BoxedTypeCache.scala              |   19 -
 .../dotc/cc/CaptureAnnotation.scala           |   77 -
 .../dotc/cc/CaptureOps.scala                  |  256 -
 .../dotc/cc/CaptureSet.scala                  |  902 ---
 .../dotc/cc/CapturingType.scala               |   72 -
 .../dotc/cc/CheckCaptures.scala               | 1039 ---
 .../pos-with-compiler-cc/dotc/cc/Setup.scala  |  482 --
 .../dotc/cc/Synthetics.scala                  |  189 -
 .../dotc/classpath/AggregateClassPath.scala   |  162 -
 .../dotc/classpath/ClassPath.scala            |   85 -
 .../dotc/classpath/ClassPathFactory.scala     |   84 -
 .../dotc/classpath/DirectoryClassPath.scala   |  313 -
 .../dotc/classpath/FileUtils.scala            |   85 -
 .../dotc/classpath/PackageNameUtils.scala     |   37 -
 .../classpath/VirtualDirectoryClassPath.scala |   55 -
 .../ZipAndJarFileLookupFactory.scala          |  205 -
 .../dotc/classpath/ZipArchiveFileLookup.scala |   72 -
 .../dotc/config/CliCommand.scala              |  198 -
 .../dotc/config/CommandLineParser.scala       |  125 -
 .../dotc/config/CompilerCommand.scala         |   26 -
 .../dotc/config/Config.scala                  |  256 -
 .../dotc/config/Feature.scala                 |  173 -
 .../dotc/config/JavaPlatform.scala            |   69 -
 .../dotc/config/OutputDirs.scala              |  117 -
 .../dotc/config/PathResolver.scala            |  268 -
 .../dotc/config/Platform.scala                |   46 -
 .../dotc/config/Printers.scala                |   52 -
 .../dotc/config/Properties.scala              |  142 -
 .../dotc/config/SJSPlatform.scala             |   35 -
 .../dotc/config/ScalaRelease.scala            |   21 -
 .../dotc/config/ScalaSettings.scala           |  347 -
 .../dotc/config/ScalaVersion.scala            |  188 -
 .../dotc/config/Settings.scala                |  295 -
 .../dotc/config/SourceVersion.scala           |   32 -
 .../dotc/config/WrappedProperties.scala       |   42 -
 .../dotc/core/Annotations.scala               |  274 -
 .../dotc/core/Atoms.scala                     |   36 -
 .../dotc/core/CheckRealizable.scala           |  216 -
 .../dotc/core/Comments.scala                  |  462 --
 .../dotc/core/Constants.scala                 |  261 -
 .../dotc/core/Constraint.scala                |  214 -
 .../dotc/core/ConstraintHandling.scala        |  891 ---
 .../dotc/core/ConstraintRunInfo.scala         |   23 -
 .../dotc/core/ContextOps.scala                |  115 -
 .../dotc/core/Contexts.scala                  | 1041 ---
 .../dotc/core/Decorators.scala                |  322 -
 .../dotc/core/Definitions.scala               | 2433 -------
 .../dotc/core/DenotTransformers.scala         |   82 -
 .../dotc/core/Denotations.scala               | 1376 ----
 .../dotc/core/Flags.scala                     |  612 --
 .../dotc/core/GadtConstraint.scala            |  267 -
 .../dotc/core/Hashable.scala                  |  126 -
 .../dotc/core/JavaNullInterop.scala           |  149 -
 .../dotc/core/MacroClassLoader.scala          |   29 -
 .../dotc/core/MatchTypeTrace.scala            |  136 -
 .../pos-with-compiler-cc/dotc/core/Mode.scala |  144 -
 .../dotc/core/NameKinds.scala                 |  414 --
 .../dotc/core/NameOps.scala                   |  400 -
 .../dotc/core/NameTags.scala                  |   68 -
 .../dotc/core/NamerOps.scala                  |  223 -
 .../dotc/core/Names.scala                     |  694 --
 .../dotc/core/NullOpsDecorator.scala          |   60 -
 .../dotc/core/OrderingConstraint.scala        | 1007 ---
 .../dotc/core/ParamInfo.scala                 |   53 -
 .../dotc/core/PatternTypeConstrainer.scala    |  298 -
 .../dotc/core/Periods.scala                   |  143 -
 .../dotc/core/Phases.scala                    |  475 --
 .../dotc/core/Scopes.scala                    |  471 --
 .../dotc/core/Signature.scala                 |  197 -
 .../dotc/core/StagingContext.scala            |   58 -
 .../dotc/core/StdNames.scala                  |  951 ---
 .../dotc/core/Substituters.scala              |  228 -
 .../dotc/core/SymDenotations.scala            | 2989 --------
 .../dotc/core/SymbolLoaders.scala             |  450 --
 .../dotc/core/Symbols.scala                   |  922 ---
 .../dotc/core/TypeApplications.scala          |  538 --
 .../dotc/core/TypeComparer.scala              | 3265 ---------
 .../dotc/core/TypeErasure.scala               |  877 ---
 .../dotc/core/TypeErrors.scala                |  176 -
 .../dotc/core/TypeEval.scala                  |  247 -
 .../dotc/core/TypeOps.scala                   |  975 ---
 .../dotc/core/TyperState.scala                |  306 -
 .../dotc/core/Types.scala                     | 6448 -----------------
 .../dotc/core/Uniques.scala                   |   92 -
 .../dotc/core/Variances.scala                 |   82 -
 .../core/classfile/AbstractFileReader.scala   |  100 -
 .../dotc/core/classfile/ByteCodecs.scala      |  224 -
 .../core/classfile/ClassfileConstants.scala   |  381 -
 .../dotc/core/classfile/ClassfileParser.scala | 1374 ----
 .../dotc/core/classfile/DataReader.scala      |   61 -
 .../core/classfile/ReusableDataReader.scala   |  150 -
 .../dotc/core/tasty/CommentPickler.scala      |   44 -
 .../dotc/core/tasty/CommentUnpickler.scala    |   35 -
 .../dotc/core/tasty/DottyUnpickler.scala      |   74 -
 .../dotc/core/tasty/NameBuffer.scala          |  126 -
 .../dotc/core/tasty/PositionPickler.scala     |  138 -
 .../dotc/core/tasty/PositionUnpickler.scala   |   77 -
 .../dotc/core/tasty/TastyAnsiiPrinter.scala   |    9 -
 .../dotc/core/tasty/TastyClassName.scala      |   68 -
 .../dotc/core/tasty/TastyHTMLPrinter.scala    |    9 -
 .../dotc/core/tasty/TastyPickler.scala        |   80 -
 .../dotc/core/tasty/TastyPrinter.scala        |  228 -
 .../dotc/core/tasty/TastyUnpickler.scala      |  109 -
 .../dotc/core/tasty/TreeBuffer.scala          |  189 -
 .../dotc/core/tasty/TreePickler.scala         |  802 --
 .../dotc/core/tasty/TreeUnpickler.scala       | 1641 -----
 .../core/unpickleScala2/PickleBuffer.scala    |  292 -
 .../core/unpickleScala2/PickleFormat.scala    |  227 -
 .../core/unpickleScala2/Scala2Erasure.scala   |  257 -
 .../core/unpickleScala2/Scala2Flags.scala     |  107 -
 .../core/unpickleScala2/Scala2Unpickler.scala | 1381 ----
 .../dotc/coverage/Coverage.scala              |   26 -
 .../dotc/coverage/Location.scala              |   50 -
 .../dotc/coverage/Serializer.scala            |  111 -
 .../decompiler/DecompilationPrinter.scala     |   48 -
 .../dotc/decompiler/IDEDecompilerDriver.scala |   50 -
 .../dotc/decompiler/Main.scala                |   27 -
 .../decompiler/PartialTASTYDecompiler.scala   |   11 -
 .../dotc/decompiler/TASTYDecompiler.scala     |   23 -
 .../AlreadyLoadedCompilationUnit.scala        |   10 -
 .../dotc/fromtasty/Debug.scala                |   74 -
 .../dotc/fromtasty/ReadTasty.scala            |   84 -
 .../dotc/fromtasty/TASTYCompilationUnit.scala |    8 -
 .../dotc/fromtasty/TASTYCompiler.scala        |   18 -
 .../dotc/fromtasty/TASTYRun.scala             |   36 -
 .../dotc/fromtasty/TastyFileUtil.scala        |   50 -
 .../dotc/inlines/InlineReducer.scala          |  451 --
 .../dotc/inlines/Inliner.scala                | 1081 ---
 .../dotc/inlines/Inlines.scala                |  471 --
 .../dotc/inlines/PrepareInlineable.scala      |  323 -
 .../dotc/interactive/Completion.scala         |  565 --
 .../dotc/interactive/Interactive.scala        |  445 --
 .../interactive/InteractiveCompiler.scala     |   21 -
 .../dotc/interactive/InteractiveDriver.scala  |  340 -
 .../dotc/interactive/SourceTree.scala         |   80 -
 .../dotc/parsing/CharArrayReader.scala        |  128 -
 .../dotc/parsing/JavaParsers.scala            | 1031 ---
 .../dotc/parsing/JavaScanners.scala           |  742 --
 .../dotc/parsing/JavaTokens.scala             |   92 -
 .../dotc/parsing/ParserPhase.scala            |   60 -
 .../dotc/parsing/Parsers.scala                | 4266 -----------
 .../dotc/parsing/Scanners.scala               | 1706 -----
 .../dotc/parsing/ScriptParsers.scala          |  147 -
 .../dotc/parsing/Tokens.scala                 |  300 -
 .../dotc/parsing/package.scala                |   40 -
 .../dotc/parsing/xml/MarkupParserCommon.scala |  257 -
 .../dotc/parsing/xml/MarkupParsers.scala      |  484 --
 .../dotc/parsing/xml/SymbolicXMLBuilder.scala |  261 -
 .../dotc/parsing/xml/Utility.scala            |  173 -
 .../dotc/plugins/Plugin.scala                 |  196 -
 .../dotc/plugins/Plugins.scala                |  278 -
 .../dotc/printing/Formatting.scala            |  167 -
 .../dotc/printing/Highlighting.scala          |   72 -
 .../dotc/printing/MessageLimiter.scala        |   61 -
 .../dotc/printing/PlainPrinter.scala          |  727 --
 .../dotc/printing/Printer.scala               |  200 -
 .../dotc/printing/RefinedPrinter.scala        | 1134 ---
 .../dotc/printing/ReplPrinter.scala           |   61 -
 .../dotc/printing/Showable.scala              |   36 -
 .../dotc/printing/SyntaxHighlighting.scala    |  147 -
 .../dotc/printing/Texts.scala                 |  213 -
 .../dotc/printing/package.scala               |   29 -
 .../dotc/profile/AsyncHelper.scala            |  142 -
 .../dotc/profile/ExtendedThreadMxBean.java    |  305 -
 .../dotc/profile/ExternalToolHook.java        |   17 -
 .../dotc/profile/Profiler.scala               |  264 -
 .../dotc/quoted/Interpreter.scala             |  371 -
 .../dotc/quoted/MacroExpansion.scala          |   18 -
 .../dotc/quoted/PickledQuotes.scala           |  270 -
 .../dotc/quoted/QuoteUtils.scala              |   30 -
 .../dotc/quoted/QuotesCache.scala             |   26 -
 .../dotc/quoted/TastyString.scala             |   31 -
 .../dotc/quoted/reflect/FromSymbol.scala      |   62 -
 tests/pos-with-compiler-cc/dotc/report.scala  |  131 -
 .../dotc/reporting/AbstractReporter.scala     |    8 -
 .../dotc/reporting/ConsoleReporter.scala      |   37 -
 .../dotc/reporting/Diagnostic.scala           |  109 -
 .../dotc/reporting/ErrorMessageID.scala       |  199 -
 .../dotc/reporting/ExploringReporter.scala    |   23 -
 .../reporting/HideNonSensicalMessages.scala   |   20 -
 .../dotc/reporting/Message.scala              |  411 --
 .../dotc/reporting/MessageKind.scala          |   41 -
 .../dotc/reporting/MessageRendering.scala     |  324 -
 .../dotc/reporting/Profile.scala              |  157 -
 .../dotc/reporting/Reporter.scala             |  271 -
 .../dotc/reporting/StoreReporter.scala        |   51 -
 .../dotc/reporting/TestReporter.scala         |   14 -
 .../dotc/reporting/ThrowingReporter.scala     |   17 -
 .../reporting/UniqueMessagePositions.scala    |   38 -
 .../dotc/reporting/WConf.scala                |  127 -
 .../dotc/reporting/messages.scala             | 2773 -------
 .../dotc/reporting/trace.scala                |  118 -
 .../dotc/rewrites/Rewrites.scala              |  102 -
 .../dotc/sbt/APIUtils.scala                   |   55 -
 .../dotc/sbt/ExtractAPI.scala                 |  833 ---
 .../dotc/sbt/ExtractDependencies.scala        |  504 --
 .../dotc/sbt/ShowAPI.scala                    |  162 -
 .../dotc/sbt/ThunkHolder.scala                |   33 -
 .../dotc/sbt/package.scala                    |   20 -
 .../dotc/semanticdb/ConstantOps.scala         |   25 -
 .../dotc/semanticdb/Descriptor.scala          |  122 -
 .../dotc/semanticdb/ExtractSemanticDB.scala   |  517 --
 .../dotc/semanticdb/LinkMode.scala            |    4 -
 .../dotc/semanticdb/PPrint.scala              |  397 -
 .../dotc/semanticdb/Scala3.scala              |  537 --
 .../semanticdb/SemanticSymbolBuilder.scala    |  152 -
 .../dotc/semanticdb/SyntheticsExtractor.scala |  151 -
 .../dotc/semanticdb/Tools.scala               |  130 -
 .../dotc/semanticdb/TypeOps.scala             |  527 --
 .../dotc/semanticdb/generated/Access.scala    |  654 --
 .../semanticdb/generated/Annotation.scala     |   91 -
 .../dotc/semanticdb/generated/Constant.scala  | 1181 ---
 .../semanticdb/generated/Diagnostic.scala     |  196 -
 .../semanticdb/generated/Documentation.scala  |  174 -
 .../dotc/semanticdb/generated/Language.scala  |   56 -
 .../dotc/semanticdb/generated/Location.scala  |  109 -
 .../dotc/semanticdb/generated/Range.scala     |  156 -
 .../dotc/semanticdb/generated/Schema.scala    |   56 -
 .../dotc/semanticdb/generated/Scope.scala     |  108 -
 .../dotc/semanticdb/generated/Signature.scala |  706 --
 .../generated/SymbolInformation.scala         |  670 --
 .../generated/SymbolOccurrence.scala          |  178 -
 .../dotc/semanticdb/generated/Synthetic.scala |  113 -
 .../semanticdb/generated/TextDocument.scala   |  271 -
 .../semanticdb/generated/TextDocuments.scala  |   87 -
 .../dotc/semanticdb/generated/Tree.scala      | 1088 ---
 .../dotc/semanticdb/generated/Type.scala      | 2036 ------
 .../InvalidProtocolBufferException.scala      |   55 -
 .../dotc/semanticdb/internal/LiteParser.scala |   36 -
 .../dotc/semanticdb/internal/MD5.scala        |   30 -
 .../semanticdb/internal/SemanticdbEnum.scala  |    5 -
 .../SemanticdbGeneratedMessageCompanion.scala |   79 -
 .../internal/SemanticdbInputStream.scala      |  802 --
 .../internal/SemanticdbMessage.scala          |    7 -
 .../internal/SemanticdbOutputStream.scala     |  610 --
 .../internal/SemanticdbTypeMapper.scala       |   18 -
 .../dotc/semanticdb/internal/WireFormat.scala |   20 -
 .../dotc/transform/AccessProxies.scala        |  174 -
 .../dotc/transform/ArrayApply.scala           |   76 -
 .../dotc/transform/ArrayConstructors.scala    |   56 -
 .../dotc/transform/BeanProperties.scala       |   65 -
 .../dotc/transform/BetaReduce.scala           |  106 -
 .../dotc/transform/Bridges.scala              |  180 -
 .../dotc/transform/CapturedVars.scala         |  173 -
 .../transform/CheckLoopingImplicits.scala     |  111 -
 .../dotc/transform/CheckNoSuperThis.scala     |   51 -
 .../dotc/transform/CheckReentrant.scala       |   92 -
 .../dotc/transform/CheckStatic.scala          |   68 -
 .../dotc/transform/CollectEntryPoints.scala   |   53 -
 .../transform/CollectNullableFields.scala     |  110 -
 .../dotc/transform/CompleteJavaEnums.scala    |  190 -
 .../dotc/transform/Constructors.scala         |  356 -
 .../transform/ContextFunctionResults.scala    |  136 -
 .../dotc/transform/CookComments.scala         |   34 -
 .../dotc/transform/CountOuterAccesses.scala   |   59 -
 .../dotc/transform/CrossStageSafety.scala     |  308 -
 .../dotc/transform/CtxLazy.scala              |   24 -
 .../dotc/transform/Dependencies.scala         |  289 -
 .../DropEmptyCompanions.scala.disabled        |   98 -
 .../dotc/transform/DropOuterAccessors.scala   |   87 -
 .../dotc/transform/ElimByName.scala           |  161 -
 .../dotc/transform/ElimErasedValueType.scala  |  143 -
 .../dotc/transform/ElimOpaque.scala           |   75 -
 .../dotc/transform/ElimOuterSelect.scala      |   38 -
 .../dotc/transform/ElimPackagePrefixes.scala  |   37 -
 .../dotc/transform/ElimPolyFunction.scala     |   71 -
 .../dotc/transform/ElimRepeated.scala         |  299 -
 .../dotc/transform/ElimStaticThis.scala       |   43 -
 .../dotc/transform/EmptyPhase.scala           |   19 -
 .../dotc/transform/Erasure.scala              | 1071 ---
 .../dotc/transform/EtaReduce.scala            |   76 -
 .../dotc/transform/ExpandPrivate.scala        |  118 -
 .../dotc/transform/ExpandSAMs.scala           |  194 -
 .../dotc/transform/ExplicitOuter.scala        |  479 --
 .../dotc/transform/ExplicitSelf.scala         |   64 -
 .../dotc/transform/ExtensionMethods.scala     |  208 -
 .../dotc/transform/FirstTransform.scala       |  219 -
 .../dotc/transform/Flatten.scala              |   66 -
 .../dotc/transform/ForwardDepChecks.scala     |  134 -
 .../dotc/transform/FullParameterization.scala |  271 -
 .../transform/FunctionXXLForwarders.scala     |   66 -
 .../dotc/transform/GenericSignatures.scala    |  481 --
 .../dotc/transform/Getters.scala              |  125 -
 .../dotc/transform/HoistSuperArgs.scala       |  246 -
 .../dotc/transform/InlinePatterns.scala       |   65 -
 .../dotc/transform/InlineVals.scala           |   59 -
 .../dotc/transform/Inlining.scala             |   83 -
 .../dotc/transform/InstrumentCoverage.scala   |  528 --
 .../dotc/transform/Instrumentation.scala      |  110 -
 .../dotc/transform/InterceptedMethods.scala   |   82 -
 .../IsInstanceOfEvaluator.scala.disabled      |  172 -
 .../dotc/transform/LambdaLift.scala           |  343 -
 .../dotc/transform/LazyVals.scala             |  700 --
 .../dotc/transform/LetOverApply.scala         |   37 -
 .../dotc/transform/LiftTry.scala              |   88 -
 .../dotc/transform/Literalize.scala.disabled  |   95 -
 .../dotc/transform/MacroTransform.scala       |   60 -
 .../dotc/transform/MegaPhase.scala            | 1066 ---
 .../dotc/transform/Memoize.scala              |  222 -
 .../dotc/transform/Mixin.scala                |  329 -
 .../dotc/transform/MixinOps.scala             |  104 -
 .../dotc/transform/MoveStatics.scala          |   93 -
 .../dotc/transform/NonLocalReturns.scala      |  106 -
 .../dotc/transform/OverridingPairs.scala      |  227 -
 .../dotc/transform/ParamForwarding.scala      |   87 -
 .../dotc/transform/PatternMatcher.scala       | 1055 ---
 .../dotc/transform/PickleQuotes.scala         |  383 -
 .../dotc/transform/Pickler.scala              |  154 -
 .../dotc/transform/PostInlining.scala         |   35 -
 .../dotc/transform/PostTyper.scala            |  500 --
 .../dotc/transform/PreRecheck.scala           |   19 -
 .../dotc/transform/ProtectedAccessors.scala   |   97 -
 .../dotc/transform/PruneErasedDefs.scala      |   72 -
 .../dotc/transform/PureStats.scala            |   35 -
 .../dotc/transform/Recheck.scala              |  576 --
 .../dotc/transform/ReifiedReflect.scala       |  109 -
 .../transform/RepeatableAnnotations.scala     |   66 -
 .../dotc/transform/ResolveSuper.scala         |  128 -
 .../dotc/transform/RestoreScopes.scala        |   56 -
 .../dotc/transform/SelectStatic.scala         |  101 -
 .../dotc/transform/SeqLiterals.scala          |   44 -
 .../dotc/transform/SetRootTree.scala          |   49 -
 .../transform/SpecializeApplyMethods.scala    |  124 -
 .../dotc/transform/SpecializeFunctions.scala  |  114 -
 .../dotc/transform/SpecializeTuples.scala     |   53 -
 .../dotc/transform/Splicer.scala              |  254 -
 .../dotc/transform/Splicing.scala             |  392 -
 .../dotc/transform/Staging.scala              |   83 -
 .../dotc/transform/SuperAccessors.scala       |  224 -
 .../dotc/transform/SymUtils.scala             |  432 --
 .../dotc/transform/SyntheticMembers.scala     |  651 --
 .../dotc/transform/TailRec.scala              |  461 --
 .../dotc/transform/TransformWildcards.scala   |   34 -
 .../dotc/transform/TreeChecker.scala          |  726 --
 .../dotc/transform/TreeExtractors.scala       |   52 -
 .../dotc/transform/TreeMapWithStages.scala    |  164 -
 .../dotc/transform/TryCatchPatterns.scala     |  104 -
 .../dotc/transform/TupleOptimizations.scala   |  221 -
 .../dotc/transform/TypeTestsCasts.scala       |  394 -
 .../dotc/transform/TypeUtils.scala            |  120 -
 .../dotc/transform/UncacheGivenAliases.scala  |   65 -
 .../dotc/transform/UninitializedDefs.scala    |   48 -
 .../dotc/transform/VCElideAllocations.scala   |   55 -
 .../dotc/transform/VCInlineMethods.scala      |  113 -
 .../dotc/transform/ValueClasses.scala         |   57 -
 .../dotc/transform/YCheckPositions.scala      |   72 -
 .../dotc/transform/init/Checker.scala         |   72 -
 .../dotc/transform/init/Errors.scala          |  145 -
 .../dotc/transform/init/Semantic.scala        | 1806 -----
 .../transform/localopt/FormatChecker.scala    |  286 -
 .../FormatInterpolatorTransform.scala         |   39 -
 .../localopt/StringInterpolatorOpt.scala      |  170 -
 .../dotc/transform/patmat/Space.scala         |  966 ---
 .../transform/sjs/AddLocalJSFakeNews.scala    |   98 -
 .../transform/sjs/ExplicitJSClasses.scala     |  730 --
 .../dotc/transform/sjs/JSExportUtils.scala    |   38 -
 .../dotc/transform/sjs/JSSymUtils.scala       |  255 -
 .../transform/sjs/JUnitBootstrappers.scala    |  332 -
 .../dotc/transform/sjs/PrepJSExports.scala    |  467 --
 .../dotc/transform/sjs/PrepJSInterop.scala    | 1329 ----
 .../dotc/typer/Applications.scala             | 2409 ------
 .../dotc/typer/Checking.scala                 | 1561 ----
 .../dotc/typer/ConstFold.scala                |  210 -
 .../dotc/typer/CrossVersionChecks.scala       |  185 -
 .../dotc/typer/Deriving.scala                 |  312 -
 .../dotc/typer/Docstrings.scala               |   67 -
 .../dotc/typer/Dynamic.scala                  |  249 -
 .../dotc/typer/ErrorReporting.scala           |  276 -
 .../dotc/typer/EtaExpansion.scala             |  293 -
 .../dotc/typer/Implicits.scala                | 1915 -----
 .../dotc/typer/ImportInfo.scala               |  231 -
 .../dotc/typer/ImportSuggestions.scala        |  358 -
 .../dotc/typer/Inferencing.scala              |  780 --
 .../dotc/typer/JavaChecks.scala               |   26 -
 .../dotc/typer/Namer.scala                    | 1916 -----
 .../dotc/typer/Nullables.scala                |  569 --
 .../dotc/typer/ProtoTypes.scala               |  958 ---
 .../dotc/typer/QuotesAndSplices.scala         |  455 --
 .../dotc/typer/ReTyper.scala                  |  146 -
 .../dotc/typer/RefChecks.scala                | 1783 -----
 .../dotc/typer/Synthesizer.scala              |  763 --
 .../dotc/typer/TypeAssigner.scala             |  546 --
 .../dotc/typer/Typer.scala                    | 4296 -----------
 .../dotc/typer/TyperPhase.scala               |  108 -
 .../dotc/typer/VarianceChecker.scala          |  209 -
 .../dotc/util/Attachment.scala                |  128 -
 .../dotc/util/CharBuffer.scala                |   28 -
 .../dotc/util/Chars.scala                     |   99 -
 .../dotc/util/ClasspathFromClassloader.scala  |   53 -
 .../dotc/util/CommentParsing.scala            |  256 -
 .../dotc/util/DiffUtil.scala                  |  234 -
 .../dotc/util/DotClass.scala                  |    8 -
 .../dotc/util/EqHashMap.scala                 |   80 -
 .../dotc/util/FreshNameCreator.scala          |   30 -
 .../dotc/util/GenericHashMap.scala            |  192 -
 .../dotc/util/HashMap.scala                   |   85 -
 .../dotc/util/HashSet.scala                   |  190 -
 .../dotc/util/IntMap.scala                    |   57 -
 .../dotc/util/LRUCache.scala                  |  104 -
 .../dotc/util/LinearMap.scala                 |   43 -
 .../dotc/util/LinearSet.scala                 |   46 -
 .../dotc/util/MutableMap.scala                |   18 -
 .../dotc/util/MutableSet.scala                |   25 -
 .../dotc/util/NameTransformer.scala           |  151 -
 .../dotc/util/ParsedComment.scala             |  224 -
 .../dotc/util/PerfectHashing.scala            |  136 -
 .../dotc/util/Property.scala                  |   18 -
 .../dotc/util/ReadOnlyMap.scala               |   41 -
 .../dotc/util/ReadOnlySet.scala               |   24 -
 .../dotc/util/ReusableInstance.scala          |   34 -
 .../dotc/util/ShowPickled.scala               |  287 -
 .../dotc/util/Signatures.scala                |  549 --
 .../dotc/util/SimpleIdentityMap.scala         |  246 -
 .../dotc/util/SimpleIdentitySet.scala         |  261 -
 .../dotc/util/SixteenNibbles.scala            |   28 -
 .../dotc/util/SourceFile.scala                |  288 -
 .../dotc/util/SourcePosition.scala            |  104 -
 .../dotc/util/Spans.scala                     |  195 -
 .../dotc/util/StackTraceOps.scala             |   78 -
 .../dotc/util/Stats.scala                     |   69 -
 .../dotc/util/Store.scala                     |   33 -
 .../pos-with-compiler-cc/dotc/util/Util.scala |   25 -
 .../dotc/util/WeakHashSet.scala               |  349 -
 .../dotc/util/common.scala                    |   14 -
 .../pos-with-compiler-cc/dotc/util/kwords.sc  |   18 -
 .../pos-with-compiler-cc/dotc/util/lrutest.sc |   40 -
 tests/pos-with-compiler-cc/package.scala      |   54 -
 480 files changed, 163760 deletions(-)
 delete mode 100644 tests/pos-with-compiler-cc/backend/ScalaPrimitivesOps.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/WorklistAlgorithm.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/AsmUtils.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/BCodeAsmCommon.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/BCodeBodyBuilder.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/BCodeHelpers.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/BCodeIdiomatic.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/BCodeSkelBuilder.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/BCodeSyncAndTry.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/BTypes.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/BTypesFromSymbols.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/BytecodeWriters.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/ClassNode1.java
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/CollectSuperCalls.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/CoreBTypes.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/DottyBackendInterface.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/GenBCode.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/GenBCodeOps.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/GenericSignatureVisitor.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/LabelNode1.java
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/MethodNode1.java
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/Primitives.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/jvm/scalaPrimitives.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/sjs/GenSJSIR.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/sjs/JSCodeGen.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/sjs/JSDefinitions.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/sjs/JSEncoding.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/sjs/JSExportsGen.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/sjs/JSPositions.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/sjs/JSPrimitives.scala
 delete mode 100644 tests/pos-with-compiler-cc/backend/sjs/ScopedVar.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/Bench.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/CompilationUnit.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/Compiler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/Driver.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/Main.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/MissingCoreLibraryException.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/Resident.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/Run.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/ScalacCommand.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/ast/CheckTrees.scala.disabled
 delete mode 100644 tests/pos-with-compiler-cc/dotc/ast/Desugar.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/ast/DesugarEnums.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/ast/MainProxies.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/ast/NavigateAST.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/ast/Positioned.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/ast/TreeInfo.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/ast/TreeMapWithImplicits.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/ast/TreeTypeMap.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/ast/Trees.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/ast/tpd.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/ast/untpd.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/cc/BoxedTypeCache.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/cc/CaptureAnnotation.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/cc/CaptureOps.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/cc/CaptureSet.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/cc/CapturingType.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/cc/CheckCaptures.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/cc/Setup.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/cc/Synthetics.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/classpath/AggregateClassPath.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/classpath/ClassPath.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/classpath/ClassPathFactory.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/classpath/DirectoryClassPath.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/classpath/FileUtils.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/classpath/PackageNameUtils.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/classpath/VirtualDirectoryClassPath.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/classpath/ZipAndJarFileLookupFactory.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/classpath/ZipArchiveFileLookup.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/CliCommand.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/CommandLineParser.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/CompilerCommand.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/Config.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/Feature.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/JavaPlatform.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/OutputDirs.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/PathResolver.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/Platform.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/Printers.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/Properties.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/SJSPlatform.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/ScalaRelease.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/ScalaSettings.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/ScalaVersion.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/Settings.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/SourceVersion.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/config/WrappedProperties.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Annotations.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Atoms.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/CheckRealizable.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Comments.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Constants.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Constraint.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/ConstraintHandling.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/ConstraintRunInfo.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/ContextOps.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Contexts.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Decorators.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Definitions.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/DenotTransformers.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Denotations.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Flags.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/GadtConstraint.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Hashable.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/JavaNullInterop.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/MacroClassLoader.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/MatchTypeTrace.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Mode.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/NameKinds.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/NameOps.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/NameTags.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/NamerOps.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Names.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/NullOpsDecorator.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/OrderingConstraint.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/ParamInfo.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/PatternTypeConstrainer.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Periods.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Phases.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Scopes.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Signature.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/StagingContext.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/StdNames.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Substituters.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/SymDenotations.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/SymbolLoaders.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Symbols.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/TypeApplications.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/TypeComparer.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/TypeErasure.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/TypeErrors.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/TypeEval.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/TypeOps.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/TyperState.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Types.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Uniques.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/Variances.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/classfile/AbstractFileReader.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/classfile/ByteCodecs.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/classfile/ClassfileConstants.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/classfile/ClassfileParser.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/classfile/DataReader.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/classfile/ReusableDataReader.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/tasty/CommentPickler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/tasty/CommentUnpickler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/tasty/DottyUnpickler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/tasty/NameBuffer.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/tasty/PositionPickler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/tasty/PositionUnpickler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/tasty/TastyAnsiiPrinter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/tasty/TastyClassName.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/tasty/TastyHTMLPrinter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/tasty/TastyPickler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/tasty/TastyPrinter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/tasty/TastyUnpickler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/tasty/TreeBuffer.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/tasty/TreePickler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/tasty/TreeUnpickler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/unpickleScala2/PickleBuffer.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/unpickleScala2/PickleFormat.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/unpickleScala2/Scala2Erasure.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/unpickleScala2/Scala2Flags.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/core/unpickleScala2/Scala2Unpickler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/coverage/Coverage.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/coverage/Location.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/coverage/Serializer.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/decompiler/DecompilationPrinter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/decompiler/IDEDecompilerDriver.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/decompiler/Main.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/decompiler/PartialTASTYDecompiler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/decompiler/TASTYDecompiler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/fromtasty/AlreadyLoadedCompilationUnit.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/fromtasty/Debug.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/fromtasty/ReadTasty.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/fromtasty/TASTYCompilationUnit.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/fromtasty/TASTYCompiler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/fromtasty/TASTYRun.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/fromtasty/TastyFileUtil.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/inlines/InlineReducer.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/inlines/Inliner.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/inlines/Inlines.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/inlines/PrepareInlineable.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/interactive/Completion.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/interactive/Interactive.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/interactive/InteractiveCompiler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/interactive/InteractiveDriver.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/interactive/SourceTree.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/parsing/CharArrayReader.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/parsing/JavaParsers.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/parsing/JavaScanners.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/parsing/JavaTokens.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/parsing/ParserPhase.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/parsing/Parsers.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/parsing/Scanners.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/parsing/ScriptParsers.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/parsing/Tokens.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/parsing/package.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/parsing/xml/MarkupParserCommon.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/parsing/xml/MarkupParsers.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/parsing/xml/SymbolicXMLBuilder.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/parsing/xml/Utility.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/plugins/Plugin.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/plugins/Plugins.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/printing/Formatting.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/printing/Highlighting.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/printing/MessageLimiter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/printing/PlainPrinter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/printing/Printer.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/printing/RefinedPrinter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/printing/ReplPrinter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/printing/Showable.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/printing/SyntaxHighlighting.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/printing/Texts.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/printing/package.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/profile/AsyncHelper.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/profile/ExtendedThreadMxBean.java
 delete mode 100644 tests/pos-with-compiler-cc/dotc/profile/ExternalToolHook.java
 delete mode 100644 tests/pos-with-compiler-cc/dotc/profile/Profiler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/quoted/Interpreter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/quoted/MacroExpansion.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/quoted/PickledQuotes.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/quoted/QuoteUtils.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/quoted/QuotesCache.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/quoted/TastyString.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/quoted/reflect/FromSymbol.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/report.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/AbstractReporter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/ConsoleReporter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/Diagnostic.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/ErrorMessageID.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/ExploringReporter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/HideNonSensicalMessages.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/Message.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/MessageKind.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/MessageRendering.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/Profile.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/Reporter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/StoreReporter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/TestReporter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/ThrowingReporter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/UniqueMessagePositions.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/WConf.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/messages.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/reporting/trace.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/rewrites/Rewrites.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/sbt/APIUtils.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/sbt/ExtractAPI.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/sbt/ExtractDependencies.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/sbt/ShowAPI.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/sbt/ThunkHolder.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/sbt/package.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/ConstantOps.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/Descriptor.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/ExtractSemanticDB.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/LinkMode.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/PPrint.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/Scala3.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/SemanticSymbolBuilder.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/SyntheticsExtractor.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/Tools.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/TypeOps.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/Access.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/Annotation.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/Constant.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/Diagnostic.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/Documentation.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/Language.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/Location.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/Range.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/Schema.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/Scope.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/Signature.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/SymbolInformation.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/SymbolOccurrence.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/Synthetic.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/TextDocument.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/TextDocuments.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/Tree.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/generated/Type.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/internal/InvalidProtocolBufferException.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/internal/LiteParser.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/internal/MD5.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbEnum.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbGeneratedMessageCompanion.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbInputStream.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbMessage.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbOutputStream.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbTypeMapper.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/semanticdb/internal/WireFormat.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/AccessProxies.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ArrayApply.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ArrayConstructors.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/BeanProperties.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/BetaReduce.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/Bridges.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/CapturedVars.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/CheckLoopingImplicits.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/CheckNoSuperThis.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/CheckReentrant.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/CheckStatic.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/CollectEntryPoints.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/CollectNullableFields.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/CompleteJavaEnums.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/Constructors.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ContextFunctionResults.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/CookComments.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/CountOuterAccesses.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/CrossStageSafety.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/CtxLazy.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/Dependencies.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/DropEmptyCompanions.scala.disabled
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/DropOuterAccessors.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ElimByName.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ElimErasedValueType.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ElimOpaque.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ElimOuterSelect.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ElimPackagePrefixes.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ElimPolyFunction.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ElimRepeated.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ElimStaticThis.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/EmptyPhase.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/Erasure.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/EtaReduce.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ExpandPrivate.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ExpandSAMs.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ExplicitOuter.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ExplicitSelf.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ExtensionMethods.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/FirstTransform.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/Flatten.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ForwardDepChecks.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/FullParameterization.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/FunctionXXLForwarders.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/GenericSignatures.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/Getters.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/HoistSuperArgs.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/InlinePatterns.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/InlineVals.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/Inlining.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/InstrumentCoverage.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/Instrumentation.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/InterceptedMethods.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/IsInstanceOfEvaluator.scala.disabled
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/LambdaLift.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/LazyVals.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/LetOverApply.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/LiftTry.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/Literalize.scala.disabled
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/MacroTransform.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/MegaPhase.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/Memoize.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/Mixin.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/MixinOps.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/MoveStatics.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/NonLocalReturns.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/OverridingPairs.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ParamForwarding.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/PatternMatcher.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/PickleQuotes.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/Pickler.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/PostInlining.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/PostTyper.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/PreRecheck.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ProtectedAccessors.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/PruneErasedDefs.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/PureStats.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/Recheck.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ReifiedReflect.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/RepeatableAnnotations.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ResolveSuper.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/RestoreScopes.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/SelectStatic.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/SeqLiterals.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/SetRootTree.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/SpecializeApplyMethods.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/SpecializeFunctions.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/SpecializeTuples.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/Splicer.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/Splicing.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/Staging.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/SuperAccessors.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/SymUtils.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/SyntheticMembers.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/TailRec.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/TransformWildcards.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/TreeChecker.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/TreeExtractors.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/TreeMapWithStages.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/TryCatchPatterns.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/TupleOptimizations.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/TypeTestsCasts.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/TypeUtils.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/UncacheGivenAliases.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/UninitializedDefs.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/VCElideAllocations.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/VCInlineMethods.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/ValueClasses.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/YCheckPositions.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/init/Checker.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/init/Errors.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/init/Semantic.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/localopt/FormatChecker.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/localopt/FormatInterpolatorTransform.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/localopt/StringInterpolatorOpt.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/patmat/Space.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/sjs/AddLocalJSFakeNews.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/sjs/ExplicitJSClasses.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/sjs/JSExportUtils.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/sjs/JSSymUtils.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/sjs/JUnitBootstrappers.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/sjs/PrepJSExports.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/transform/sjs/PrepJSInterop.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/Applications.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/Checking.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/ConstFold.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/CrossVersionChecks.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/Deriving.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/Docstrings.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/Dynamic.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/ErrorReporting.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/EtaExpansion.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/Implicits.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/ImportInfo.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/ImportSuggestions.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/Inferencing.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/JavaChecks.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/Namer.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/Nullables.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/ProtoTypes.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/QuotesAndSplices.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/ReTyper.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/RefChecks.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/Synthesizer.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/TypeAssigner.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/Typer.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/TyperPhase.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/typer/VarianceChecker.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/Attachment.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/CharBuffer.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/Chars.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/ClasspathFromClassloader.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/CommentParsing.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/DiffUtil.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/DotClass.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/EqHashMap.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/FreshNameCreator.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/GenericHashMap.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/HashMap.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/HashSet.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/IntMap.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/LRUCache.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/LinearMap.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/LinearSet.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/MutableMap.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/MutableSet.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/NameTransformer.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/ParsedComment.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/PerfectHashing.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/Property.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/ReadOnlyMap.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/ReadOnlySet.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/ReusableInstance.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/ShowPickled.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/Signatures.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/SimpleIdentityMap.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/SimpleIdentitySet.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/SixteenNibbles.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/SourceFile.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/SourcePosition.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/Spans.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/StackTraceOps.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/Stats.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/Store.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/Util.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/WeakHashSet.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/common.scala
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/kwords.sc
 delete mode 100644 tests/pos-with-compiler-cc/dotc/util/lrutest.sc
 delete mode 100644 tests/pos-with-compiler-cc/package.scala

diff --git a/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala b/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala
index 5cd4f837b823..3b19f1d3d4bb 100644
--- a/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala
@@ -32,13 +32,6 @@ 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/tests/pos-with-compiler-cc/backend/ScalaPrimitivesOps.scala b/tests/pos-with-compiler-cc/backend/ScalaPrimitivesOps.scala
deleted file mode 100644
index 6b5bfbc3e00e..000000000000
--- a/tests/pos-with-compiler-cc/backend/ScalaPrimitivesOps.scala
+++ /dev/null
@@ -1,232 +0,0 @@
-package dotty.tools
-package backend
-
-object ScalaPrimitivesOps extends ScalaPrimitivesOps
-
-class ScalaPrimitivesOps {
-  // Arithmetic unary operations
-  inline val POS = 1                            // +x
-  inline val NEG = 2                            // -x
-  inline val NOT = 3                            // ~x
-
-  // Arithmetic binary operations
-  inline val ADD = 10                           // x + y
-  inline val SUB = 11                           // x - y
-  inline val MUL = 12                           // x * y
-  inline val DIV = 13                           // x / y
-  inline val MOD = 14                           // x % y
-
-  // Bitwise operations
-  inline val OR  = 20                           // x | y
-  inline val XOR = 21                           // x ^ y
-  inline val AND = 22                           // x & y
-
-  // Shift operations
-  inline val LSL = 30                           // x << y
-  inline val LSR = 31                           // x >>> y
-  inline val ASR = 32                           // x >> y
-
-  // Comparison operations
-  inline val ID = 40                            // x eq y
-  inline val NI = 41                            // x ne y
-  inline val EQ = 42                            // x == y
-  inline val NE = 43                            // x != y
-  inline val LT = 44                            // x < y
-  inline val LE = 45                            // x <= y
-  inline val GT = 46                            // x > y
-  inline val GE = 47                            // x >= y
-
-  // Boolean unary operations
-  inline val ZNOT = 50                          // !x
-
-  // Boolean binary operations
-  inline val ZOR = 60                           // x || y
-  inline val ZAND = 61                          // x && y
-
-  // Array operations
-  inline val LENGTH = 70                        // x.length
-  inline val APPLY  = 71                        // x(y)
-  inline val UPDATE = 72                        // x(y) = z
-
-  // Any operations
-  inline val IS = 80                            // x.is[y]
-  inline val AS = 81                            // x.as[y]
-  inline val HASH = 87                          // x.##
-
-  // AnyRef operations
-  inline val SYNCHRONIZED = 90                  // x.synchronized(y)
-
-  // String operations
-  inline val CONCAT = 100                       // String.valueOf(x)+String.valueOf(y)
-
-  // coercions
-  inline val COERCE = 101
-
-  // RunTime operations
-  inline val BOX = 110                          // RunTime.box_<X>(x)
-  inline val UNBOX = 111                        // RunTime.unbox_<X>(x)
-  inline val NEW_ZARRAY = 112                   // RunTime.zarray(x)
-  inline val NEW_BARRAY = 113                   // RunTime.barray(x)
-  inline val NEW_SARRAY = 114                   // RunTime.sarray(x)
-  inline val NEW_CARRAY = 115                   // RunTime.carray(x)
-  inline val NEW_IARRAY = 116                   // RunTime.iarray(x)
-  inline val NEW_LARRAY = 117                   // RunTime.larray(x)
-  inline val NEW_FARRAY = 118                   // RunTime.farray(x)
-  inline val NEW_DARRAY = 119                   // RunTime.darray(x)
-  inline val NEW_OARRAY = 120                   // RunTime.oarray(x)
-
-  inline val ZARRAY_LENGTH = 131                // RunTime.zarray_length(x)
-  inline val BARRAY_LENGTH = 132                // RunTime.barray_length(x)
-  inline val SARRAY_LENGTH = 133                // RunTime.sarray_length(x)
-  inline val CARRAY_LENGTH = 134                // RunTime.carray_length(x)
-  inline val IARRAY_LENGTH = 135                // RunTime.iarray_length(x)
-  inline val LARRAY_LENGTH = 136                // RunTime.larray_length(x)
-  inline val FARRAY_LENGTH = 137                // RunTime.farray_length(x)
-  inline val DARRAY_LENGTH = 138                // RunTime.darray_length(x)
-  inline val OARRAY_LENGTH = 139                // RunTime.oarray_length(x)
-
-  inline val ZARRAY_GET = 140                   // RunTime.zarray_get(x,y)
-  inline val BARRAY_GET = 141                   // RunTime.barray_get(x,y)
-  inline val SARRAY_GET = 142                   // RunTime.sarray_get(x,y)
-  inline val CARRAY_GET = 143                   // RunTime.carray_get(x,y)
-  inline val IARRAY_GET = 144                   // RunTime.iarray_get(x,y)
-  inline val LARRAY_GET = 145                   // RunTime.larray_get(x,y)
-  inline val FARRAY_GET = 146                   // RunTime.farray_get(x,y)
-  inline val DARRAY_GET = 147                   // RunTime.darray_get(x,y)
-  inline val OARRAY_GET = 148                   // RunTime.oarray_get(x,y)
-
-  inline val ZARRAY_SET = 150                   // RunTime.zarray(x,y,z)
-  inline val BARRAY_SET = 151                   // RunTime.barray(x,y,z)
-  inline val SARRAY_SET = 152                   // RunTime.sarray(x,y,z)
-  inline val CARRAY_SET = 153                   // RunTime.carray(x,y,z)
-  inline val IARRAY_SET = 154                   // RunTime.iarray(x,y,z)
-  inline val LARRAY_SET = 155                   // RunTime.larray(x,y,z)
-  inline val FARRAY_SET = 156                   // RunTime.farray(x,y,z)
-  inline val DARRAY_SET = 157                   // RunTime.darray(x,y,z)
-  inline val OARRAY_SET = 158                   // RunTime.oarray(x,y,z)
-
-  inline val B2B = 200                          // RunTime.b2b(x)
-  inline val B2S = 201                          // RunTime.b2s(x)
-  inline val B2C = 202                          // RunTime.b2c(x)
-  inline val B2I = 203                          // RunTime.b2i(x)
-  inline val B2L = 204                          // RunTime.b2l(x)
-  inline val B2F = 205                          // RunTime.b2f(x)
-  inline val B2D = 206                          // RunTime.b2d(x)
-
-  inline val S2B = 210                          // RunTime.s2b(x)
-  inline val S2S = 211                          // RunTime.s2s(x)
-  inline val S2C = 212                          // RunTime.s2c(x)
-  inline val S2I = 213                          // RunTime.s2i(x)
-  inline val S2L = 214                          // RunTime.s2l(x)
-  inline val S2F = 215                          // RunTime.s2f(x)
-  inline val S2D = 216                          // RunTime.s2d(x)
-
-  inline val C2B = 220                          // RunTime.c2b(x)
-  inline val C2S = 221                          // RunTime.c2s(x)
-  inline val C2C = 222                          // RunTime.c2c(x)
-  inline val C2I = 223                          // RunTime.c2i(x)
-  inline val C2L = 224                          // RunTime.c2l(x)
-  inline val C2F = 225                          // RunTime.c2f(x)
-  inline val C2D = 226                          // RunTime.c2d(x)
-
-  inline val I2B = 230                          // RunTime.i2b(x)
-  inline val I2S = 231                          // RunTime.i2s(x)
-  inline val I2C = 232                          // RunTime.i2c(x)
-  inline val I2I = 233                          // RunTime.i2i(x)
-  inline val I2L = 234                          // RunTime.i2l(x)
-  inline val I2F = 235                          // RunTime.i2f(x)
-  inline val I2D = 236                          // RunTime.i2d(x)
-
-  inline val L2B = 240                          // RunTime.l2b(x)
-  inline val L2S = 241                          // RunTime.l2s(x)
-  inline val L2C = 242                          // RunTime.l2c(x)
-  inline val L2I = 243                          // RunTime.l2i(x)
-  inline val L2L = 244                          // RunTime.l2l(x)
-  inline val L2F = 245                          // RunTime.l2f(x)
-  inline val L2D = 246                          // RunTime.l2d(x)
-
-  inline val F2B = 250                          // RunTime.f2b(x)
-  inline val F2S = 251                          // RunTime.f2s(x)
-  inline val F2C = 252                          // RunTime.f2c(x)
-  inline val F2I = 253                          // RunTime.f2i(x)
-  inline val F2L = 254                          // RunTime.f2l(x)
-  inline val F2F = 255                          // RunTime.f2f(x)
-  inline val F2D = 256                          // RunTime.f2d(x)
-
-  inline val D2B = 260                          // RunTime.d2b(x)
-  inline val D2S = 261                          // RunTime.d2s(x)
-  inline val D2C = 262                          // RunTime.d2c(x)
-  inline val D2I = 263                          // RunTime.d2i(x)
-  inline val D2L = 264                          // RunTime.d2l(x)
-  inline val D2F = 265                          // RunTime.d2f(x)
-  inline val D2D = 266                          // RunTime.d2d(x)
-
-  /** Check whether the given operation code is an array operation. */
-  def isArrayOp(code: Int): Boolean =
-    isArrayNew(code) | isArrayLength(code) | isArrayGet(code) | isArraySet(code)
-
-  def isArrayNew(code: Int): Boolean = code match {
-    case NEW_ZARRAY | NEW_BARRAY | NEW_SARRAY | NEW_CARRAY |
-         NEW_IARRAY | NEW_LARRAY | NEW_FARRAY | NEW_DARRAY |
-         NEW_OARRAY => true
-    case _ => false
-  }
-
-  def isArrayLength(code: Int): Boolean = code match {
-    case ZARRAY_LENGTH | BARRAY_LENGTH | SARRAY_LENGTH | CARRAY_LENGTH |
-         IARRAY_LENGTH | LARRAY_LENGTH | FARRAY_LENGTH | DARRAY_LENGTH |
-         OARRAY_LENGTH | LENGTH => true
-    case _ => false
-  }
-
-  def isArrayGet(code: Int): Boolean = code match {
-    case ZARRAY_GET | BARRAY_GET | SARRAY_GET | CARRAY_GET |
-         IARRAY_GET | LARRAY_GET | FARRAY_GET | DARRAY_GET |
-         OARRAY_GET | APPLY => true
-    case _ => false
-  }
-
-  def isArraySet(code: Int): Boolean = code match {
-    case ZARRAY_SET | BARRAY_SET | SARRAY_SET | CARRAY_SET |
-         IARRAY_SET | LARRAY_SET | FARRAY_SET | DARRAY_SET |
-         OARRAY_SET | UPDATE => true
-    case _ => false
-  }
-
-  /** Check whether the given code is a comparison operator */
-  def isComparisonOp(code: Int): Boolean = code match {
-    case ID | NI | EQ | NE |
-         LT | LE | GT | GE => true
-
-    case _ => false
-  }
-  def isUniversalEqualityOp(code: Int): Boolean = (code == EQ) || (code == NE)
-  def isReferenceEqualityOp(code: Int): Boolean = (code == ID) || (code == NI)
-
-  def isArithmeticOp(code: Int): Boolean = code match {
-    case POS | NEG | NOT => true; // unary
-    case ADD | SUB | MUL |
-         DIV | MOD       => true; // binary
-    case OR  | XOR | AND |
-         LSL | LSR | ASR => true; // bitwise
-    case _ => false
-  }
-
-  def isLogicalOp(code: Int): Boolean = code match {
-    case ZNOT | ZAND | ZOR => true
-    case _ => false
-  }
-
-  def isShiftOp(code: Int): Boolean = code match {
-    case LSL | LSR | ASR => true
-    case _ => false
-  }
-
-  def isBitwiseOp(code: Int): Boolean = code match {
-    case OR | XOR | AND => true
-    case _ => false
-  }
-
-  def isCoercion(code: Int): Boolean = (code >= B2B) && (code <= D2D)
-
-}
diff --git a/tests/pos-with-compiler-cc/backend/WorklistAlgorithm.scala b/tests/pos-with-compiler-cc/backend/WorklistAlgorithm.scala
deleted file mode 100644
index b3d98d425b2a..000000000000
--- a/tests/pos-with-compiler-cc/backend/WorklistAlgorithm.scala
+++ /dev/null
@@ -1,57 +0,0 @@
-package dotty.tools
-package backend
-
-/**
- * Simple implementation of a worklist algorithm. A processing
- * function is applied repeatedly to the first element in the
- * worklist, as long as the stack is not empty.
- *
- * The client class should mix-in this class and initialize the worklist
- * field and define the `processElement` method. Then call the `run` method
- * providing a function that initializes the worklist.
- *
- * @author  Martin Odersky
- * @version 1.0
- * @see     [[scala.tools.nsc.backend.icode.Linearizers]]
- */
-trait WorklistAlgorithm {
-  type Elem
-  class WList {
-    private var list: List[Elem] = Nil
-    def isEmpty = list.isEmpty
-    def nonEmpty = !isEmpty
-    def push(e: Elem): Unit = { list = e :: list }
-    def pop(): Elem = {
-      val head = list.head
-      list = list.tail
-      head
-    }
-    def pushAll(xs: Iterable[Elem]): Unit = xs.foreach(push)
-    def clear(): Unit = list = Nil
-
-  }
-
-  val worklist: WList
-
-  /**
-   * Run the iterative algorithm until the worklist remains empty.
-   * The initializer is run once before the loop starts and should
-   * initialize the worklist.
-   */
-  def run(initWorklist: => Unit) = {
-    initWorklist
-
-    while (worklist.nonEmpty)
-      processElement(dequeue)
-  }
-
-  /**
-   * Process the current element from the worklist.
-   */
-  def processElement(e: Elem): Unit
-
-  /**
-   * Remove and return the first element to be processed from the worklist.
-   */
-  def dequeue: Elem
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/AsmUtils.scala b/tests/pos-with-compiler-cc/backend/jvm/AsmUtils.scala
deleted file mode 100644
index e6393ce82054..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/AsmUtils.scala
+++ /dev/null
@@ -1,65 +0,0 @@
-package dotty.tools
-package backend
-package jvm
-
-import scala.language.unsafeNulls
-
-import scala.tools.asm.tree.{AbstractInsnNode}
-import java.io.PrintWriter
-import scala.tools.asm.util.{TraceClassVisitor, TraceMethodVisitor, Textifier}
-import scala.tools.asm.ClassReader
-
-object AsmUtils {
-
-  /**
-   * Print the bytecode of methods generated by GenBCode to the standard output. Only methods
-   * whose name contains `traceMethodPattern` are traced.
-   */
-  final val traceMethodEnabled = sys.env.contains("printBCODE")
-  final val traceMethodPattern = sys.env.getOrElse("printBCODE", "")
-
-  /**
-   * Print the bytecode of classes generated by GenBCode to the standard output.
-   */
-  inline val traceClassEnabled = false
-  inline val traceClassPattern = ""
-
-  /**
-   * Print the bytedcode of classes as they are serialized by the ASM library. The serialization
-   * performed by `asm.ClassWriter` can change the code generated by GenBCode. For example, it
-   * introduces stack map frames, it computes the maximal stack sizes, and it replaces dead
-   * code by NOPs (see also https://github.com/scala/scala/pull/3726#issuecomment-42861780).
-   */
-  inline val traceSerializedClassEnabled = false
-  inline val traceSerializedClassPattern = ""
-
-  def traceMethod(mnode: MethodNode1): Unit = {
-    println(s"Bytecode for method ${mnode.name}")
-    val p = new Textifier
-    val tracer = new TraceMethodVisitor(p)
-    mnode.accept(tracer)
-    val w = new PrintWriter(System.out)
-    p.print(w)
-    w.flush()
-  }
-
-  def traceClass(cnode: ClassNode1): Unit = {
-    println(s"Bytecode for class ${cnode.name}")
-    val w = new PrintWriter(System.out)
-    cnode.accept(new TraceClassVisitor(w))
-    w.flush()
-  }
-
-  def traceClass(bytes: Array[Byte]): Unit = traceClass(readClass(bytes))
-
-  def readClass(bytes: Array[Byte]): ClassNode1 = {
-    val node = new ClassNode1()
-    new ClassReader(bytes).accept(node, 0)
-    node
-  }
-
-  def instructionString(instruction: AbstractInsnNode): String = instruction.getOpcode match {
-    case -1 => instruction.toString
-    case op => scala.tools.asm.util.Printer.OPCODES(op)
-  }
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/BCodeAsmCommon.scala b/tests/pos-with-compiler-cc/backend/jvm/BCodeAsmCommon.scala
deleted file mode 100644
index d95638be2695..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/BCodeAsmCommon.scala
+++ /dev/null
@@ -1,158 +0,0 @@
-package dotty.tools
-package backend
-package jvm
-
-import scala.language.unsafeNulls
-
-import dotty.tools.dotc.core.Flags._
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.report
-
-/**
- * This trait contains code shared between GenBCode and GenASM that depends on types defined in
- * the compiler cake (Global).
- */
-final class BCodeAsmCommon[I <: DottyBackendInterface](val interface: I) {
-  import interface.given
-  import DottyBackendInterface.symExtensions
-
-  /**
-   * True if `classSym` is an anonymous class or a local class. I.e., false if `classSym` is a
-   * member class. This method is used to decide if we should emit an EnclosingMethod attribute.
-   * It is also used to decide whether the "owner" field in the InnerClass attribute should be
-   * null.
-   */
-  def isAnonymousOrLocalClass(classSym: Symbol): Boolean = {
-    assert(classSym.isClass, s"not a class: $classSym")
-    // Here used to be an `assert(!classSym.isDelambdafyFunction)`: delambdafy lambda classes are
-    // always top-level. However, SI-8900 shows an example where the weak name-based implementation
-    // of isDelambdafyFunction failed (for a function declared in a package named "lambda").
-    classSym.isAnonymousClass || {
-      val originalOwner = classSym.originalOwner
-      originalOwner != NoSymbol && !originalOwner.isClass
-    }
-  }
-
-  /**
-   * Returns the enclosing method for non-member classes. In the following example
-   *
-   * class A {
-   *   def f = {
-   *     class B {
-   *       class C
-   *     }
-   *   }
-   * }
-   *
-   * the method returns Some(f) for B, but None for C, because C is a member class. For non-member
-   * classes that are not enclosed by a method, it returns None:
-   *
-   * class A {
-   *   { class B }
-   * }
-   *
-   * In this case, for B, we return None.
-   *
-   * The EnclosingMethod attribute needs to be added to non-member classes (see doc in BTypes).
-   * This is a source-level property, so we need to use the originalOwner chain to reconstruct it.
-   */
-  private def enclosingMethodForEnclosingMethodAttribute(classSym: Symbol): Option[Symbol] = {
-    assert(classSym.isClass, classSym)
-    def enclosingMethod(sym: Symbol): Option[Symbol] = {
-      if (sym.isClass || sym == NoSymbol) None
-      else if (sym.is(Method)) Some(sym)
-      else enclosingMethod(sym.originalOwner)
-    }
-    enclosingMethod(classSym.originalOwner)
-  }
-
-  /**
-   * The enclosing class for emitting the EnclosingMethod attribute. Since this is a source-level
-   * property, this method looks at the originalOwner chain. See doc in BTypes.
-   */
-  private def enclosingClassForEnclosingMethodAttribute(classSym: Symbol): Symbol = {
-    assert(classSym.isClass, classSym)
-    def enclosingClass(sym: Symbol): Symbol = {
-      if (sym.isClass) sym
-      else enclosingClass(sym.originalOwner.originalLexicallyEnclosingClass)
-    }
-    enclosingClass(classSym.originalOwner.originalLexicallyEnclosingClass)
-  }
-
-  /*final*/ case class EnclosingMethodEntry(owner: String, name: String, methodDescriptor: String)
-
-  /**
-   * Data for emitting an EnclosingMethod attribute. None if `classSym` is a member class (not
-   * an anonymous or local class). See doc in BTypes.
-   *
-   * The class is parametrized by two functions to obtain a bytecode class descriptor for a class
-   * symbol, and to obtain a method signature descriptor fro a method symbol. These function depend
-   * on the implementation of GenASM / GenBCode, so they need to be passed in.
-   */
-  def enclosingMethodAttribute(classSym: Symbol, classDesc: Symbol => String, methodDesc: Symbol => String): Option[EnclosingMethodEntry] = {
-    if (isAnonymousOrLocalClass(classSym)) {
-      val methodOpt = enclosingMethodForEnclosingMethodAttribute(classSym)
-      report.debuglog(s"enclosing method for $classSym is $methodOpt (in ${methodOpt.map(_.enclosingClass)})")
-      Some(EnclosingMethodEntry(
-        classDesc(enclosingClassForEnclosingMethodAttribute(classSym)),
-        methodOpt.map(_.javaSimpleName).orNull,
-        methodOpt.map(methodDesc).orNull))
-    } else {
-      None
-    }
-  }
-}
-
-object BCodeAsmCommon{
-  def ubytesToCharArray(bytes: Array[Byte]): Array[Char] = {
-    val ca = new Array[Char](bytes.length)
-    var idx = 0
-    while(idx < bytes.length) {
-      val b: Byte = bytes(idx)
-      assert((b & ~0x7f) == 0)
-      ca(idx) = b.asInstanceOf[Char]
-      idx += 1
-    }
-
-    ca
-  }
-
-  final def arrEncode(bSeven: Array[Byte]): Array[String] = {
-    var strs: List[String]  = Nil
-    // chop into slices of at most 65535 bytes, counting 0x00 as taking two bytes (as per JVMS 4.4.7 The CONSTANT_Utf8_info Structure)
-    var prevOffset = 0
-    var offset     = 0
-    var encLength  = 0
-    while(offset < bSeven.length) {
-      val deltaEncLength = (if(bSeven(offset) == 0) 2 else 1)
-      val newEncLength = encLength.toLong + deltaEncLength
-      if(newEncLength >= 65535) {
-        val ba     = bSeven.slice(prevOffset, offset)
-        strs     ::= new java.lang.String(ubytesToCharArray(ba))
-        encLength  = 0
-        prevOffset = offset
-      } else {
-        encLength += deltaEncLength
-        offset    += 1
-      }
-    }
-    if(prevOffset < offset) {
-      assert(offset == bSeven.length)
-      val ba = bSeven.slice(prevOffset, offset)
-      strs ::= new java.lang.String(ubytesToCharArray(ba))
-    }
-    assert(strs.size > 1, "encode instead as one String via strEncode()") // TODO too strict?
-    strs.reverse.toArray
-  }
-
-
-  def strEncode(bSeven: Array[Byte]): String = {
-    val ca = ubytesToCharArray(bSeven)
-    new java.lang.String(ca)
-    // debug val bvA = new asm.ByteVector; bvA.putUTF8(s)
-    // debug val enc: Array[Byte] = scala.reflect.internal.pickling.ByteCodecs.encode(bytes)
-    // debug assert(enc(idx) == bvA.getByte(idx + 2))
-    // debug assert(bvA.getLength == enc.size + 2)
-  }
-
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/BCodeBodyBuilder.scala b/tests/pos-with-compiler-cc/backend/jvm/BCodeBodyBuilder.scala
deleted file mode 100644
index da6d213351b7..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/BCodeBodyBuilder.scala
+++ /dev/null
@@ -1,1776 +0,0 @@
-package dotty.tools
-package backend
-package jvm
-
-import scala.language.unsafeNulls
-
-import scala.annotation.switch
-import scala.collection.mutable.SortedMap
-
-import scala.tools.asm
-import scala.tools.asm.{Handle, Opcodes}
-import BCodeHelpers.InvokeStyle
-
-import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.CompilationUnit
-import dotty.tools.dotc.core.Constants._
-import dotty.tools.dotc.core.Flags.{Label => LabelFlag, _}
-import dotty.tools.dotc.core.Types._
-import dotty.tools.dotc.core.StdNames.{nme, str}
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.transform.Erasure
-import dotty.tools.dotc.transform.SymUtils._
-import dotty.tools.dotc.util.Spans._
-import dotty.tools.dotc.core.Contexts._
-import dotty.tools.dotc.core.Phases._
-import dotty.tools.dotc.core.Decorators.em
-import dotty.tools.dotc.report
-
-/*
- *
- *  @author  Miguel Garcia, http://lamp.epfl.ch/~magarcia/ScalaCompilerCornerReloaded/
- *  @version 1.0
- *
- */
-trait BCodeBodyBuilder extends BCodeSkelBuilder {
-  // import global._
-  // import definitions._
-  import tpd._
-  import int.{_, given}
-  import DottyBackendInterface.symExtensions
-  import bTypes._
-  import coreBTypes._
-
-  protected val primitives: DottyPrimitives
-
-  /*
-   * Functionality to build the body of ASM MethodNode, except for `synchronized` and `try` expressions.
-   */
-  abstract class PlainBodyBuilder(cunit: CompilationUnit) extends PlainSkelBuilder(cunit) {
-
-    import Primitives.TestOp
-
-    /* ---------------- helper utils for generating methods and code ---------------- */
-
-    def emit(opc: Int): Unit = { mnode.visitInsn(opc) }
-
-    def emitZeroOf(tk: BType): Unit = {
-      tk match {
-        case BOOL => bc.boolconst(false)
-        case BYTE  |
-             SHORT |
-             CHAR  |
-             INT     => bc.iconst(0)
-        case LONG    => bc.lconst(0)
-        case FLOAT   => bc.fconst(0)
-        case DOUBLE  => bc.dconst(0)
-        case UNIT    => ()
-        case _ => emit(asm.Opcodes.ACONST_NULL)
-      }
-    }
-
-    /*
-     * Emits code that adds nothing to the operand stack.
-     * Two main cases: `tree` is an assignment,
-     * otherwise an `adapt()` to UNIT is performed if needed.
-     */
-    def genStat(tree: Tree): Unit = {
-      lineNumber(tree)
-
-      tree match {
-        case Assign(lhs @ DesugaredSelect(qual, _), rhs) =>
-          val isStatic = lhs.symbol.isStaticMember
-          if (!isStatic) { genLoadQualifier(lhs) }
-          genLoad(rhs, symInfoTK(lhs.symbol))
-          lineNumber(tree)
-          // receiverClass is used in the bytecode to access the field. using sym.owner may lead to IllegalAccessError
-          val receiverClass = qual.tpe.typeSymbol
-          fieldStore(lhs.symbol, receiverClass)
-
-        case Assign(lhs, rhs) =>
-          val s = lhs.symbol
-          val Local(tk, _, idx, _) = locals.getOrMakeLocal(s)
-
-          rhs match {
-            case Apply(Select(larg: Ident, nme.ADD), Literal(x) :: Nil)
-            if larg.symbol == s && tk.isIntSizedType && x.isShortRange =>
-              lineNumber(tree)
-              bc.iinc(idx, x.intValue)
-
-            case Apply(Select(larg: Ident, nme.SUB), Literal(x) :: Nil)
-            if larg.symbol == s && tk.isIntSizedType && Constant(-x.intValue).isShortRange =>
-              lineNumber(tree)
-              bc.iinc(idx, -x.intValue)
-
-            case _ =>
-              genLoad(rhs, tk)
-              lineNumber(tree)
-              bc.store(idx, tk)
-          }
-
-        case _ =>
-          genLoad(tree, UNIT)
-      }
-    }
-
-    /* Generate code for primitive arithmetic operations. */
-    def genArithmeticOp(tree: Tree, code: Int): BType = tree match{
-      case Apply(fun @ DesugaredSelect(larg, _), args) =>
-      var resKind = tpeTK(larg)
-
-      assert(resKind.isNumericType || (resKind == BOOL),
-             s"$resKind is not a numeric or boolean type [operation: ${fun.symbol}]")
-
-      import ScalaPrimitivesOps._
-
-      args match {
-        // unary operation
-        case Nil =>
-          genLoad(larg, resKind)
-          code match {
-            case POS => () // nothing
-            case NEG => bc.neg(resKind)
-            case NOT => bc.genPrimitiveArithmetic(Primitives.NOT, resKind)
-            case _ => abort(s"Unknown unary operation: ${fun.symbol.showFullName} code: $code")
-          }
-
-        // binary operation
-        case rarg :: Nil =>
-          val isShift = isShiftOp(code)
-          resKind = tpeTK(larg).maxType(if (isShift) INT else tpeTK(rarg))
-
-          if (isShift || isBitwiseOp(code)) {
-            assert(resKind.isIntegralType || (resKind == BOOL),
-                   s"$resKind incompatible with arithmetic modulo operation.")
-          }
-
-          genLoad(larg, resKind)
-          genLoad(rarg, if (isShift) INT else resKind)
-
-          (code: @switch) match {
-            case ADD => bc add resKind
-            case SUB => bc sub resKind
-            case MUL => bc mul resKind
-            case DIV => bc div resKind
-            case MOD => bc rem resKind
-
-            case OR  | XOR | AND => bc.genPrimitiveLogical(code, resKind)
-
-            case LSL | LSR | ASR => bc.genPrimitiveShift(code, resKind)
-
-            case _                   => abort(s"Unknown primitive: ${fun.symbol}[$code]")
-          }
-
-        case _ =>
-          abort(s"Too many arguments for primitive function: $tree")
-      }
-      lineNumber(tree)
-      resKind
-    }
-
-    /* Generate primitive array operations. */
-    def genArrayOp(tree: Tree, code: Int, expectedType: BType): BType = tree match{
-
-      case Apply(DesugaredSelect(arrayObj, _), args) =>
-      import ScalaPrimitivesOps._
-      val k = tpeTK(arrayObj)
-      genLoad(arrayObj, k)
-      val elementType = typeOfArrayOp.getOrElse[bTypes.BType](code, abort(s"Unknown operation on arrays: $tree code: $code"))
-
-      var generatedType = expectedType
-
-      if (isArrayGet(code)) {
-        // load argument on stack
-        assert(args.length == 1, s"Too many arguments for array get operation: $tree");
-        genLoad(args.head, INT)
-        generatedType = k.asArrayBType.componentType
-        bc.aload(elementType)
-      }
-      else if (isArraySet(code)) {
-        val List(a1, a2) = args
-        genLoad(a1, INT)
-        genLoad(a2)
-        generatedType = UNIT
-        bc.astore(elementType)
-      } else {
-        generatedType = INT
-        emit(asm.Opcodes.ARRAYLENGTH)
-      }
-      lineNumber(tree)
-
-      generatedType
-    }
-
-    def genLoadIfTo(tree: If, expectedType: BType, dest: LoadDestination): BType = tree match{
-      case If(condp, thenp, elsep) =>
-
-      val success = new asm.Label
-      val failure = new asm.Label
-
-      val hasElse = !elsep.isEmpty && (elsep match {
-        case Literal(value) if value.tag == UnitTag => false
-        case _ => true
-      })
-
-      genCond(condp, success, failure, targetIfNoJump = success)
-      markProgramPoint(success)
-
-      if dest == LoadDestination.FallThrough then
-        if hasElse then
-          val thenKind      = tpeTK(thenp)
-          val elseKind      = tpeTK(elsep)
-          def hasUnitBranch = (thenKind == UNIT || elseKind == UNIT) && expectedType == UNIT
-          val resKind       = if (hasUnitBranch) UNIT else tpeTK(tree)
-
-          val postIf = new asm.Label
-          genLoadTo(thenp, resKind, LoadDestination.Jump(postIf))
-          markProgramPoint(failure)
-          genLoadTo(elsep, resKind, LoadDestination.FallThrough)
-          markProgramPoint(postIf)
-          resKind
-        else
-          genLoad(thenp, UNIT)
-          markProgramPoint(failure)
-          UNIT
-        end if
-      else
-        genLoadTo(thenp, expectedType, dest)
-        markProgramPoint(failure)
-        if hasElse then
-          genLoadTo(elsep, expectedType, dest)
-        else
-          genAdaptAndSendToDest(UNIT, expectedType, dest)
-        expectedType
-      end if
-    }
-
-    def genPrimitiveOp(tree: Apply, expectedType: BType): BType = (tree: @unchecked) match {
-      case Apply(fun @ DesugaredSelect(receiver, _), _) =>
-      val sym = tree.symbol
-
-      val code = primitives.getPrimitive(tree, receiver.tpe)
-
-      import ScalaPrimitivesOps._
-
-      if (isArithmeticOp(code))                genArithmeticOp(tree, code)
-      else if (code == CONCAT) genStringConcat(tree)
-      else if (code == HASH)   genScalaHash(receiver)
-      else if (isArrayOp(code))                genArrayOp(tree, code, expectedType)
-      else if (isLogicalOp(code) || isComparisonOp(code)) {
-        val success, failure, after = new asm.Label
-        genCond(tree, success, failure, targetIfNoJump = success)
-        // success block
-        markProgramPoint(success)
-        bc boolconst true
-        bc goTo after
-        // failure block
-        markProgramPoint(failure)
-        bc boolconst false
-        // after
-        markProgramPoint(after)
-
-        BOOL
-      }
-      else if (isCoercion(code)) {
-        genLoad(receiver)
-        lineNumber(tree)
-        genCoercion(code)
-        coercionTo(code)
-      }
-      else abort(
-        s"Primitive operation not handled yet: ${sym.showFullName}(${fun.symbol.name}) at: ${tree.span}"
-      )
-    }
-
-    def genLoad(tree: Tree): Unit = {
-      genLoad(tree, tpeTK(tree))
-    }
-
-    /* Generate code for trees that produce values on the stack */
-    def genLoad(tree: Tree, expectedType: BType): Unit =
-      genLoadTo(tree, expectedType, LoadDestination.FallThrough)
-
-    /* Generate code for trees that produce values, sent to a given `LoadDestination`. */
-    def genLoadTo(tree: Tree, expectedType: BType, dest: LoadDestination): Unit =
-      var generatedType = expectedType
-      var generatedDest = LoadDestination.FallThrough
-
-      lineNumber(tree)
-
-      tree match {
-        case tree@ValDef(_, _, _) =>
-          val sym = tree.symbol
-          /* most of the time, !locals.contains(sym), unless the current activation of genLoad() is being called
-             while duplicating a finalizer that contains this ValDef. */
-          val loc = locals.getOrMakeLocal(sym)
-          val Local(tk, _, idx, isSynth) = loc
-          if (tree.rhs == tpd.EmptyTree) { emitZeroOf(tk) }
-          else { genLoad(tree.rhs, tk) }
-          bc.store(idx, tk)
-          val localVarStart = currProgramPoint()
-          if (!isSynth) { // there are case <synthetic> ValDef's emitted by patmat
-            varsInScope ::= (sym -> localVarStart)
-          }
-          generatedType = UNIT
-
-        case t @ If(_, _, _) =>
-          generatedType = genLoadIfTo(t, expectedType, dest)
-          generatedDest = dest
-
-        case t @ Labeled(_, _) =>
-          generatedType = genLabeledTo(t, expectedType, dest)
-          generatedDest = dest
-
-        case r: Return =>
-          genReturn(r)
-          generatedDest = LoadDestination.Return
-
-        case t @ WhileDo(_, _) =>
-          generatedDest = genWhileDo(t)
-          generatedType = UNIT
-
-        case t @ Try(_, _, _) =>
-          generatedType = genLoadTry(t)
-
-        case t: Apply if t.fun.symbol eq defn.throwMethod =>
-          val thrownExpr = t.args.head
-          val thrownKind = tpeTK(thrownExpr)
-          genLoadTo(thrownExpr, thrownKind, LoadDestination.Throw)
-          generatedDest = LoadDestination.Throw
-
-        case New(tpt) =>
-          abort(s"Unexpected New(${tpt.tpe.showSummary()}/$tpt) reached GenBCode.\n" +
-                "  Call was genLoad" + ((tree, expectedType)))
-
-        case t @ Closure(env, call, tpt) =>
-          val functionalInterface: Symbol =
-            if !tpt.isEmpty then tpt.tpe.classSymbol
-            else t.tpe.classSymbol
-          val (fun, args) = call match {
-            case Apply(fun, args) => (fun, args)
-            case t @ DesugaredSelect(_, _) => (t, Nil) // TODO: use Select
-            case t @ Ident(_) => (t, Nil)
-          }
-
-          if (!fun.symbol.isStaticMember) {
-            // load receiver of non-static implementation of lambda
-
-            // darkdimius: I haven't found in spec `this` reference should go
-            // but I was able to derrive it by reading
-            // AbstractValidatingLambdaMetafactory.validateMetafactoryArgs
-
-            val DesugaredSelect(prefix, _) = fun: @unchecked
-            genLoad(prefix)
-          }
-
-          genLoadArguments(env, fun.symbol.info.firstParamTypes map toTypeKind)
-          generatedType = genInvokeDynamicLambda(NoSymbol, fun.symbol, env.size, functionalInterface)
-
-        case app @ Apply(_, _) =>
-          generatedType = genApply(app, expectedType)
-
-        case This(qual) =>
-          val symIsModuleClass = tree.symbol.is(ModuleClass)
-          assert(tree.symbol == claszSymbol || symIsModuleClass,
-                 s"Trying to access the this of another class: tree.symbol = ${tree.symbol}, class symbol = $claszSymbol compilation unit: $cunit")
-          if (symIsModuleClass && tree.symbol != claszSymbol) {
-            generatedType = genLoadModule(tree)
-          }
-          else {
-            mnode.visitVarInsn(asm.Opcodes.ALOAD, 0)
-            // When compiling Array.scala, the constructor invokes `Array.this.super.<init>`. The expectedType
-            // is `[Object` (computed by typeToBType, the type of This(Array) is `Array[T]`). If we would set
-            // the generatedType to `Array` below, the call to adapt at the end would fail. The situation is
-            // similar for primitives (`I` vs `Int`).
-            if (tree.symbol != defn.ArrayClass && !tree.symbol.isPrimitiveValueClass) {
-              generatedType = classBTypeFromSymbol(claszSymbol)
-            }
-          }
-
-        case DesugaredSelect(Ident(nme.EMPTY_PACKAGE), module) =>
-          assert(tree.symbol.is(Module), s"Selection of non-module from empty package: $tree sym: ${tree.symbol} at: ${tree.span}")
-          genLoadModule(tree)
-
-        case DesugaredSelect(qualifier, _) =>
-          val sym = tree.symbol
-          generatedType = symInfoTK(sym)
-          val qualSafeToElide = tpd.isIdempotentExpr(qualifier)
-
-          def genLoadQualUnlessElidable(): Unit = { if (!qualSafeToElide) { genLoadQualifier(tree) } }
-
-          // receiverClass is used in the bytecode to access the field. using sym.owner may lead to IllegalAccessError
-          def receiverClass = qualifier.tpe.typeSymbol
-          if (sym.is(Module)) {
-            genLoadQualUnlessElidable()
-            genLoadModule(tree)
-          } else if (sym.isStaticMember) {
-            genLoadQualUnlessElidable()
-            fieldLoad(sym, receiverClass)
-          } else {
-            genLoadQualifier(tree)
-            fieldLoad(sym, receiverClass)
-          }
-
-        case t @ Ident(name) =>
-          val sym = tree.symbol
-          val tk = symInfoTK(sym)
-          generatedType = tk
-
-          val desugared = cachedDesugarIdent(t)
-          desugared match {
-            case None =>
-              if (!sym.is(Package)) {
-                if (sym.is(Module)) genLoadModule(sym)
-                else locals.load(sym)
-              }
-            case Some(t) =>
-              genLoad(t, generatedType)
-          }
-
-        case Literal(value) =>
-          if (value.tag != UnitTag) (value.tag, expectedType) match {
-            case (IntTag,   LONG  ) => bc.lconst(value.longValue);       generatedType = LONG
-            case (FloatTag, DOUBLE) => bc.dconst(value.doubleValue);     generatedType = DOUBLE
-            case (NullTag,  _     ) => bc.emit(asm.Opcodes.ACONST_NULL); generatedType = srNullRef
-            case _                  => genConstant(value);               generatedType = tpeTK(tree)
-          }
-
-        case blck @ Block(stats, expr) =>
-          if(stats.isEmpty)
-            genLoadTo(expr, expectedType, dest)
-          else
-            genBlockTo(blck, expectedType, dest)
-          generatedDest = dest
-
-        case Typed(Super(_, _), _) =>
-          genLoadTo(tpd.This(claszSymbol.asClass), expectedType, dest)
-          generatedDest = dest
-
-        case Typed(expr, _) =>
-          genLoadTo(expr, expectedType, dest)
-          generatedDest = dest
-
-        case Assign(_, _) =>
-          generatedType = UNIT
-          genStat(tree)
-
-        case av @ ArrayValue(_, _) =>
-          generatedType = genArrayValue(av)
-
-        case mtch @ Match(_, _) =>
-          generatedType = genMatchTo(mtch, expectedType, dest)
-          generatedDest = dest
-
-        case tpd.EmptyTree => if (expectedType != UNIT) { emitZeroOf(expectedType) }
-
-
-        case t: TypeApply => // dotty specific
-          generatedType = genTypeApply(t)
-
-        case _ => abort(s"Unexpected tree in genLoad: $tree/${tree.getClass} at: ${tree.span}")
-      }
-
-      // emit conversion and send to the right destination
-      if generatedDest == LoadDestination.FallThrough then
-        genAdaptAndSendToDest(generatedType, expectedType, dest)
-    end genLoadTo
-
-    def genAdaptAndSendToDest(generatedType: BType, expectedType: BType, dest: LoadDestination): Unit =
-      if generatedType != expectedType then
-        adapt(generatedType, expectedType)
-
-      dest match
-        case LoadDestination.FallThrough =>
-          ()
-        case LoadDestination.Jump(label) =>
-          bc goTo label
-        case LoadDestination.Return =>
-          bc emitRETURN returnType
-        case LoadDestination.Throw =>
-          val thrownType = expectedType
-          // `throw null` is valid although scala.Null (as defined in src/libray-aux) isn't a subtype of Throwable.
-          // Similarly for scala.Nothing (again, as defined in src/libray-aux).
-          assert(thrownType.isNullType || thrownType.isNothingType || thrownType.asClassBType.isSubtypeOf(jlThrowableRef))
-          emit(asm.Opcodes.ATHROW)
-    end genAdaptAndSendToDest
-
-    // ---------------- field load and store ----------------
-
-    /*
-     * must-single-thread
-     */
-    def fieldLoad( field: Symbol, hostClass: Symbol = null): Unit = fieldOp(field, isLoad = true,  hostClass)
-
-    /*
-     * must-single-thread
-     */
-    def fieldStore(field: Symbol, hostClass: Symbol = null): Unit = fieldOp(field, isLoad = false, hostClass)
-
-    /*
-     * must-single-thread
-     */
-    private def fieldOp(field: Symbol, isLoad: Boolean, specificReceiver: Symbol): Unit = {
-      val useSpecificReceiver = specificReceiver != null && !field.isScalaStatic
-
-      val owner      = internalName(if (useSpecificReceiver) specificReceiver else field.owner)
-      val fieldJName = field.javaSimpleName
-      val fieldDescr = symInfoTK(field).descriptor
-      val isStatic   = field.isStaticMember
-      val opc =
-        if (isLoad) { if (isStatic) asm.Opcodes.GETSTATIC else asm.Opcodes.GETFIELD }
-        else        { if (isStatic) asm.Opcodes.PUTSTATIC else asm.Opcodes.PUTFIELD }
-      mnode.visitFieldInsn(opc, owner, fieldJName, fieldDescr)
-
-    }
-
-    // ---------------- emitting constant values ----------------
-
-    /*
-     * For ClazzTag:
-     *   must-single-thread
-     * Otherwise it's safe to call from multiple threads.
-     */
-    def genConstant(const: Constant): Unit = {
-      (const.tag/*: @switch*/) match {
-
-        case BooleanTag => bc.boolconst(const.booleanValue)
-
-        case ByteTag    => bc.iconst(const.byteValue)
-        case ShortTag   => bc.iconst(const.shortValue)
-        case CharTag    => bc.iconst(const.charValue)
-        case IntTag     => bc.iconst(const.intValue)
-
-        case LongTag    => bc.lconst(const.longValue)
-        case FloatTag   => bc.fconst(const.floatValue)
-        case DoubleTag  => bc.dconst(const.doubleValue)
-
-        case UnitTag    => ()
-
-        case StringTag  =>
-          assert(const.value != null, const) // TODO this invariant isn't documented in `case class Constant`
-          mnode.visitLdcInsn(const.stringValue) // `stringValue` special-cases null, but not for a const with StringTag
-
-        case NullTag    => emit(asm.Opcodes.ACONST_NULL)
-
-        case ClazzTag   =>
-          val tp = toTypeKind(const.typeValue)
-          if tp.isPrimitive then
-            val boxedClass = boxedClassOfPrimitive(tp.asPrimitiveBType)
-            mnode.visitFieldInsn(
-              asm.Opcodes.GETSTATIC,
-              boxedClass.internalName,
-              "TYPE", // field name
-              jlClassRef.descriptor
-            )
-          else
-            mnode.visitLdcInsn(tp.toASMType)
-
-        case _ => abort(s"Unknown constant value: $const")
-      }
-    }
-
-    private def genLabeledTo(tree: Labeled, expectedType: BType, dest: LoadDestination): BType = tree match {
-      case Labeled(bind, expr) =>
-
-      val labelSym = bind.symbol
-
-      if dest == LoadDestination.FallThrough then
-        val resKind = tpeTK(tree)
-        val jumpTarget = new asm.Label
-        registerJumpDest(labelSym, resKind, LoadDestination.Jump(jumpTarget))
-        genLoad(expr, resKind)
-        markProgramPoint(jumpTarget)
-        resKind
-      else
-        registerJumpDest(labelSym, expectedType, dest)
-        genLoadTo(expr, expectedType, dest)
-        expectedType
-      end if
-    }
-
-    private def genReturn(r: Return): Unit = {
-      val expr: Tree = r.expr
-      val fromSym: Symbol = if (r.from.symbol.is(LabelFlag)) r.from.symbol else NoSymbol
-
-      if (NoSymbol == fromSym) {
-        // return from enclosing method
-        cleanups match {
-          case Nil =>
-            // not an assertion: !shouldEmitCleanup (at least not yet, pendingCleanups() may still have to run, and reset `shouldEmitCleanup`.
-            genLoadTo(expr, returnType, LoadDestination.Return)
-          case nextCleanup :: rest =>
-            genLoad(expr, returnType)
-            lineNumber(r)
-            val saveReturnValue = (returnType != UNIT)
-            if (saveReturnValue) {
-              // regarding return value, the protocol is: in place of a `return-stmt`, a sequence of `adapt, store, jump` are inserted.
-              if (earlyReturnVar == null) {
-                earlyReturnVar = locals.makeLocal(returnType, "earlyReturnVar", expr.tpe, expr.span)
-              }
-              locals.store(earlyReturnVar)
-            }
-            bc goTo nextCleanup
-            shouldEmitCleanup = true
-        }
-      } else {
-        // return from labeled
-        assert(fromSym.is(LabelFlag), fromSym)
-        assert(!fromSym.is(Method), fromSym)
-
-        /* TODO At the moment, we disregard cleanups, because by construction we don't have return-from-labels
-         * that cross cleanup boundaries. However, in theory such crossings are valid, so we should take care
-         * of them.
-         */
-        val (exprExpectedType, exprDest) = findJumpDest(fromSym)
-        genLoadTo(expr, exprExpectedType, exprDest)
-      }
-    } // end of genReturn()
-
-    def genWhileDo(tree: WhileDo): LoadDestination = tree match{
-      case WhileDo(cond, body) =>
-
-      val isInfinite = cond == tpd.EmptyTree
-
-      val loop = new asm.Label
-      markProgramPoint(loop)
-
-      if isInfinite then
-        val dest = LoadDestination.Jump(loop)
-        genLoadTo(body, UNIT, dest)
-        dest
-      else
-        body match
-          case Literal(value) if value.tag == UnitTag =>
-            // this is the shape of do..while loops
-            val exitLoop = new asm.Label
-            genCond(cond, loop, exitLoop, targetIfNoJump = exitLoop)
-            markProgramPoint(exitLoop)
-          case _ =>
-            val success = new asm.Label
-            val failure = new asm.Label
-            genCond(cond, success, failure, targetIfNoJump = success)
-            markProgramPoint(success)
-            genLoadTo(body, UNIT, LoadDestination.Jump(loop))
-            markProgramPoint(failure)
-        end match
-        LoadDestination.FallThrough
-    }
-
-    def genTypeApply(t: TypeApply): BType = (t: @unchecked) match {
-      case TypeApply(fun@DesugaredSelect(obj, _), targs) =>
-
-        val sym = fun.symbol
-        val cast =
-          if (sym == defn.Any_isInstanceOf) false
-          else if (sym == defn.Any_asInstanceOf) true
-          else abort(s"Unexpected type application $fun[sym: ${sym.showFullName}] in: $t")
-        val l = tpeTK(obj)
-        val r = tpeTK(targs.head)
-        genLoadQualifier(fun)
-
-        // TODO @lry make pattern match
-        if (l.isPrimitive && r.isPrimitive)
-          genConversion(l, r, cast)
-        else if (l.isPrimitive) {
-          bc drop l
-          if (cast) {
-            mnode.visitTypeInsn(asm.Opcodes.NEW, jlClassCastExceptionRef.internalName)
-            bc dup ObjectRef
-            emit(asm.Opcodes.ATHROW)
-          } else {
-            bc boolconst false
-          }
-        }
-        else if (r.isPrimitive && cast) {
-          abort(s"Erasure should have added an unboxing operation to prevent this cast. Tree: $t")
-        }
-        else if (r.isPrimitive) {
-          bc isInstance boxedClassOfPrimitive(r.asPrimitiveBType)
-        }
-        else {
-          assert(r.isRef, r) // ensure that it's not a method
-          genCast(r.asRefBType, cast)
-        }
-
-        if (cast) r else BOOL
-    } // end of genTypeApply()
-
-
-    private def mkArrayConstructorCall(arr: ArrayBType, app: Apply, args: List[Tree]) = {
-      val dims     = arr.dimension
-      var elemKind = arr.elementType
-      val argsSize = args.length
-      if (argsSize > dims) {
-        report.error(em"too many arguments for array constructor: found ${args.length} but array has only $dims dimension(s)", ctx.source.atSpan(app.span))
-      }
-      if (argsSize < dims) {
-        /* In one step:
-         *   elemKind = new BType(BType.ARRAY, arr.off + argsSize, arr.len - argsSize)
-         * however the above does not enter a TypeName for each nested arrays in chrs.
-         */
-        for (i <- args.length until dims) elemKind = ArrayBType(elemKind)
-      }
-      genLoadArguments(args, List.fill(args.size)(INT))
-      (argsSize /*: @switch*/) match {
-        case 1 => bc newarray elemKind
-        case _ =>
-          val descr = ("[" * argsSize) + elemKind.descriptor // denotes the same as: arrayN(elemKind, argsSize).descriptor
-          mnode.visitMultiANewArrayInsn(descr, argsSize)
-      }
-    }
-
-
-    private def genApply(app: Apply, expectedType: BType): BType = {
-      var generatedType = expectedType
-      lineNumber(app)
-      app match {
-        case Apply(_, args) if app.symbol eq defn.newArrayMethod =>
-          val List(elemClaz, Literal(c: Constant), ArrayValue(_, dims)) = args: @unchecked
-
-          generatedType = toTypeKind(c.typeValue)
-          mkArrayConstructorCall(generatedType.asArrayBType, app, dims)
-        case Apply(t :TypeApply, _) =>
-          generatedType =
-            if (t.symbol ne defn.Object_synchronized) genTypeApply(t)
-            else genSynchronized(app, expectedType)
-
-        case Apply(fun @ DesugaredSelect(Super(superQual, _), _), args) =>
-          // 'super' call: Note: since constructors are supposed to
-          // return an instance of what they construct, we have to take
-          // special care. On JVM they are 'void', and Scala forbids (syntactically)
-          // to call super constructors explicitly and/or use their 'returned' value.
-          // therefore, we can ignore this fact, and generate code that leaves nothing
-          // on the stack (contrary to what the type in the AST says).
-
-          // scala/bug#10290: qual can be `this.$outer()` (not just `this`), so we call genLoad (not just ALOAD_0)
-          genLoad(superQual)
-          genLoadArguments(args, paramTKs(app))
-          generatedType = genCallMethod(fun.symbol, InvokeStyle.Super, app.span)
-
-        // 'new' constructor call: Note: since constructors are
-        // thought to return an instance of what they construct,
-        // we have to 'simulate' it by DUPlicating the freshly created
-        // instance (on JVM, <init> methods return VOID).
-        case Apply(fun @ DesugaredSelect(New(tpt), nme.CONSTRUCTOR), args) =>
-          val ctor = fun.symbol
-          assert(ctor.isClassConstructor, s"'new' call to non-constructor: ${ctor.name}")
-
-          generatedType = toTypeKind(tpt.tpe)
-          assert(generatedType.isRef, s"Non reference type cannot be instantiated: $generatedType")
-
-          generatedType match {
-            case arr: ArrayBType =>
-              mkArrayConstructorCall(arr, app, args)
-
-            case rt: ClassBType =>
-              assert(classBTypeFromSymbol(ctor.owner) == rt, s"Symbol ${ctor.owner.showFullName} is different from $rt")
-              mnode.visitTypeInsn(asm.Opcodes.NEW, rt.internalName)
-              bc dup generatedType
-              genLoadArguments(args, paramTKs(app))
-              genCallMethod(ctor, InvokeStyle.Special, app.span)
-
-            case _ =>
-              abort(s"Cannot instantiate $tpt of kind: $generatedType")
-          }
-
-        case Apply(fun, List(expr)) if Erasure.Boxing.isBox(fun.symbol) && fun.symbol.denot.owner != defn.UnitModuleClass =>
-          val nativeKind = tpeTK(expr)
-          genLoad(expr, nativeKind)
-          val MethodNameAndType(mname, methodType) = asmBoxTo(nativeKind)
-          bc.invokestatic(srBoxesRuntimeRef.internalName, mname, methodType.descriptor, itf = false)
-          generatedType = boxResultType(fun.symbol) // was toTypeKind(fun.symbol.tpe.resultType)
-
-        case Apply(fun, List(expr)) if Erasure.Boxing.isUnbox(fun.symbol) && fun.symbol.denot.owner != defn.UnitModuleClass =>
-          genLoad(expr)
-          val boxType = unboxResultType(fun.symbol) // was toTypeKind(fun.symbol.owner.linkedClassOfClass.tpe)
-          generatedType = boxType
-          val MethodNameAndType(mname, methodType) = asmUnboxTo(boxType)
-          bc.invokestatic(srBoxesRuntimeRef.internalName, mname, methodType.descriptor, itf = false)
-
-        case app @ Apply(fun, args) =>
-          val sym = fun.symbol
-
-          if (isPrimitive(fun)) { // primitive method call
-            generatedType = genPrimitiveOp(app, expectedType)
-          } else { // normal method call
-            val invokeStyle =
-              if (sym.isStaticMember) InvokeStyle.Static
-              else if (sym.is(Private) || sym.isClassConstructor) InvokeStyle.Special
-              else if (app.hasAttachment(BCodeHelpers.UseInvokeSpecial)) InvokeStyle.Special
-              else InvokeStyle.Virtual
-
-            if (invokeStyle.hasInstance) genLoadQualifier(fun)
-            genLoadArguments(args, paramTKs(app))
-
-            val DesugaredSelect(qual, name) = fun: @unchecked // fun is a Select, also checked in genLoadQualifier
-            val isArrayClone = name == nme.clone_ && qual.tpe.widen.isInstanceOf[JavaArrayType]
-            if (isArrayClone) {
-              // Special-case Array.clone, introduced in 36ef60e. The goal is to generate this call
-              // as "[I.clone" instead of "java/lang/Object.clone". This is consistent with javac.
-              // Arrays have a public method `clone` (jls 10.7).
-              //
-              // The JVMS is not explicit about this, but that receiver type can be an array type
-              // descriptor (instead of a class internal name):
-              //   invokevirtual  #2; //Method "[I".clone:()Ljava/lang/Object
-              //
-              // Note that using `Object.clone()` would work as well, but only because the JVM
-              // relaxes protected access specifically if the receiver is an array:
-              //   http://hg.openjdk.java.net/jdk8/jdk8/hotspot/file/87ee5ee27509/src/share/vm/interpreter/linkResolver.cpp#l439
-              // Example: `class C { override def clone(): Object = "hi" }`
-              // Emitting `def f(c: C) = c.clone()` as `Object.clone()` gives a VerifyError.
-              val target: String = tpeTK(qual).asRefBType.classOrArrayType
-              val methodBType = asmMethodType(sym)
-              bc.invokevirtual(target, sym.javaSimpleName, methodBType.descriptor)
-              generatedType = methodBType.returnType
-            } else {
-              val receiverClass = if (!invokeStyle.isVirtual) null else {
-                // receiverClass is used in the bytecode to as the method receiver. using sym.owner
-                // may lead to IllegalAccessErrors, see 9954eaf / aladdin bug 455.
-                val qualSym = qual.tpe.typeSymbol
-                if (qualSym == defn.ArrayClass) {
-                  // For invocations like `Array(1).hashCode` or `.wait()`, use Object as receiver
-                  // in the bytecode. Using the array descriptor (like we do for clone above) seems
-                  // to work as well, but it seems safer not to change this. Javac also uses Object.
-                  // Note that array apply/update/length are handled by isPrimitive (above).
-                  assert(sym.owner == defn.ObjectClass, s"unexpected array call: $app")
-                  defn.ObjectClass
-                } else qualSym
-              }
-              generatedType = genCallMethod(sym, invokeStyle, app.span, receiverClass)
-            }
-          }
-      }
-
-      generatedType
-    } // end of genApply()
-
-    private def genArrayValue(av: tpd.JavaSeqLiteral): BType = {
-      val ArrayValue(tpt, elems) = av: @unchecked
-
-      lineNumber(av)
-      genArray(elems, tpt)
-    }
-
-    private def genArray(elems: List[Tree], elemType: Type): BType = {
-      val elmKind       = toTypeKind(elemType)
-      val generatedType = ArrayBType(elmKind)
-
-      bc iconst   elems.length
-      bc newarray elmKind
-
-      var i = 0
-      var rest = elems
-      while (!rest.isEmpty) {
-        bc dup     generatedType
-        bc iconst  i
-        genLoad(rest.head, elmKind)
-        bc astore  elmKind
-        rest = rest.tail
-        i = i + 1
-      }
-
-      generatedType
-    }
-
-    /* A Match node contains one or more case clauses, each case clause lists one or more
-     * Int/String values to use as keys, and a code block. The exception is the "default" case
-     * clause which doesn't list any key (there is exactly one of these per match).
-     */
-    private def genMatchTo(tree: Match, expectedType: BType, dest: LoadDestination): BType = tree match {
-      case Match(selector, cases) =>
-      lineNumber(tree)
-
-      val (generatedType, postMatch, postMatchDest) =
-        if dest == LoadDestination.FallThrough then
-          val postMatch = new asm.Label
-          (tpeTK(tree), postMatch, LoadDestination.Jump(postMatch))
-        else
-          (expectedType, null, dest)
-
-      // Only two possible selector types exist in `Match` trees at this point: Int and String
-      if (tpeTK(selector) == INT) {
-
-        /* On a first pass over the case clauses, we flatten the keys and their
-         * targets (the latter represented with asm.Labels). That representation
-         * allows JCodeMethodV to emit a lookupswitch or a tableswitch.
-         *
-         * On a second pass, we emit the switch blocks, one for each different target.
-         */
-
-        var flatKeys: List[Int]       = Nil
-        var targets:  List[asm.Label] = Nil
-        var default:  asm.Label       = null
-        var switchBlocks: List[(asm.Label, Tree)] = Nil
-
-        genLoad(selector, INT)
-
-        // collect switch blocks and their keys, but don't emit yet any switch-block.
-        for (caze @ CaseDef(pat, guard, body) <- cases) {
-          assert(guard == tpd.EmptyTree, guard)
-          val switchBlockPoint = new asm.Label
-          switchBlocks ::= (switchBlockPoint, body)
-          pat match {
-            case Literal(value) =>
-              flatKeys ::= value.intValue
-              targets  ::= switchBlockPoint
-            case Ident(nme.WILDCARD) =>
-              assert(default == null, s"multiple default targets in a Match node, at ${tree.span}")
-              default = switchBlockPoint
-            case Alternative(alts) =>
-              alts foreach {
-                case Literal(value) =>
-                  flatKeys ::= value.intValue
-                  targets  ::= switchBlockPoint
-                case _ =>
-                  abort(s"Invalid alternative in alternative pattern in Match node: $tree at: ${tree.span}")
-              }
-            case _ =>
-              abort(s"Invalid pattern in Match node: $tree at: ${tree.span}")
-          }
-        }
-
-        bc.emitSWITCH(mkArrayReverse(flatKeys), mkArrayL(targets.reverse), default, MIN_SWITCH_DENSITY)
-
-        // emit switch-blocks.
-        for (sb <- switchBlocks.reverse) {
-          val (caseLabel, caseBody) = sb
-          markProgramPoint(caseLabel)
-          genLoadTo(caseBody, generatedType, postMatchDest)
-        }
-      } else {
-
-        /* Since the JVM doesn't have a way to switch on a string, we  switch
-         * on the `hashCode` of the string then do an `equals` check (with a
-         * possible second set of jumps if blocks can be reach from multiple
-         * string alternatives).
-         *
-         * This mirrors the way that Java compiles `switch` on Strings.
-         */
-
-        var default:  asm.Label       = null
-        var indirectBlocks: List[(asm.Label, Tree)] = Nil
-
-
-        // Cases grouped by their hashCode
-        val casesByHash = SortedMap.empty[Int, List[(String, Either[asm.Label, Tree])]]
-        var caseFallback: Tree = null
-
-        for (caze @ CaseDef(pat, guard, body) <- cases) {
-          assert(guard == tpd.EmptyTree, guard)
-          pat match {
-            case Literal(value) =>
-              val strValue = value.stringValue
-              casesByHash.updateWith(strValue.##) { existingCasesOpt =>
-                val newCase = (strValue, Right(body))
-                Some(newCase :: existingCasesOpt.getOrElse(Nil))
-              }
-            case Ident(nme.WILDCARD) =>
-              assert(default == null, s"multiple default targets in a Match node, at ${tree.span}")
-              default = new asm.Label
-              indirectBlocks ::= (default, body)
-            case Alternative(alts) =>
-              // We need an extra basic block since multiple strings can lead to this code
-              val indirectCaseGroupLabel = new asm.Label
-              indirectBlocks ::= (indirectCaseGroupLabel, body)
-              alts foreach {
-                case Literal(value) =>
-                  val strValue = value.stringValue
-                  casesByHash.updateWith(strValue.##) { existingCasesOpt =>
-                    val newCase = (strValue, Left(indirectCaseGroupLabel))
-                    Some(newCase :: existingCasesOpt.getOrElse(Nil))
-                  }
-                case _ =>
-                  abort(s"Invalid alternative in alternative pattern in Match node: $tree at: ${tree.span}")
-              }
-
-            case _ =>
-              abort(s"Invalid pattern in Match node: $tree at: ${tree.span}")
-          }
-        }
-
-        // Organize the hashCode options into switch cases
-        var flatKeys: List[Int]       = Nil
-        var targets:  List[asm.Label] = Nil
-        var hashBlocks: List[(asm.Label, List[(String, Either[asm.Label, Tree])])] = Nil
-        for ((hashValue, hashCases) <- casesByHash) {
-          val switchBlockPoint = new asm.Label
-          hashBlocks ::= (switchBlockPoint, hashCases)
-          flatKeys ::= hashValue
-          targets  ::= switchBlockPoint
-        }
-
-        // Push the hashCode of the string (or `0` it is `null`) onto the stack and switch on it
-        genLoadIfTo(
-          If(
-            tree.selector.select(defn.Any_==).appliedTo(nullLiteral),
-            Literal(Constant(0)),
-            tree.selector.select(defn.Any_hashCode).appliedToNone
-          ),
-          INT,
-          LoadDestination.FallThrough
-        )
-        bc.emitSWITCH(mkArrayReverse(flatKeys), mkArrayL(targets.reverse), default, MIN_SWITCH_DENSITY)
-
-        // emit blocks for each hash case
-        for ((hashLabel, caseAlternatives) <- hashBlocks.reverse) {
-          markProgramPoint(hashLabel)
-          for ((caseString, indirectLblOrBody) <- caseAlternatives) {
-            val comparison = if (caseString == null) defn.Any_== else defn.Any_equals
-            val condp = Literal(Constant(caseString)).select(defn.Any_==).appliedTo(tree.selector)
-            val keepGoing = new asm.Label
-            indirectLblOrBody match {
-              case Left(jump) =>
-                genCond(condp, jump, keepGoing, targetIfNoJump = keepGoing)
-
-              case Right(caseBody) =>
-                val thisCaseMatches = new asm.Label
-                genCond(condp, thisCaseMatches, keepGoing, targetIfNoJump = thisCaseMatches)
-                markProgramPoint(thisCaseMatches)
-                genLoadTo(caseBody, generatedType, postMatchDest)
-            }
-            markProgramPoint(keepGoing)
-          }
-          bc goTo default
-        }
-
-        // emit blocks for common patterns
-        for ((caseLabel, caseBody) <- indirectBlocks.reverse) {
-          markProgramPoint(caseLabel)
-          genLoadTo(caseBody, generatedType, postMatchDest)
-        }
-      }
-
-      if postMatch != null then
-        markProgramPoint(postMatch)
-      generatedType
-    }
-
-    def genBlockTo(tree: Block, expectedType: BType, dest: LoadDestination): Unit = tree match {
-      case Block(stats, expr) =>
-
-      val savedScope = varsInScope
-      varsInScope = Nil
-      stats foreach genStat
-      genLoadTo(expr, expectedType, dest)
-      emitLocalVarScopes()
-      varsInScope = savedScope
-    }
-
-    /** Add entries to the `LocalVariableTable` JVM attribute for all the vars in
-     *  `varsInScope`, ending at the current program point.
-     */
-    def emitLocalVarScopes(): Unit =
-      if (emitVars) {
-        val end = currProgramPoint()
-        for ((sym, start) <- varsInScope.reverse) {
-          emitLocalVarScope(sym, start, end)
-        }
-      }
-    end emitLocalVarScopes
-
-    def adapt(from: BType, to: BType): Unit = {
-      if (!from.conformsTo(to)) {
-        to match {
-          case UNIT => bc drop from
-          case _    => bc.emitT2T(from, to)
-        }
-      } else if (from.isNothingType) {
-        /* There are two possibilities for from.isNothingType: emitting a "throw e" expressions and
-         * loading a (phantom) value of type Nothing.
-         *
-         * The Nothing type in Scala's type system does not exist in the JVM. In bytecode, Nothing
-         * is mapped to scala.runtime.Nothing$. To the JVM, a call to Predef.??? looks like it would
-         * return an object of type Nothing$. We need to do something with that phantom object on
-         * the stack. "Phantom" because it never exists: such methods always throw, but the JVM does
-         * not know that.
-         *
-         * Note: The two verifiers (old: type inference, new: type checking) have different
-         * requirements. Very briefly:
-         *
-         * Old (http://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.10.2.1): at
-         * each program point, no matter what branches were taken to get there
-         *   - Stack is same size and has same typed values
-         *   - Local and stack values need to have consistent types
-         *   - In practice, the old verifier seems to ignore unreachable code and accept any
-         *     instructions after an ATHROW. For example, there can be another ATHROW (without
-         *     loading another throwable first).
-         *
-         * New (http://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.10.1)
-         *   - Requires consistent stack map frames. GenBCode generates stack frames if -target:jvm-1.6
-         *     or higher.
-         *   - In practice: the ASM library computes stack map frames for us (ClassWriter). Emitting
-         *     correct frames after an ATHROW is probably complex, so ASM uses the following strategy:
-         *       - Every time when generating an ATHROW, a new basic block is started.
-         *       - During classfile writing, such basic blocks are found to be dead: no branches go there
-         *       - Eliminating dead code would probably require complex shifts in the output byte buffer
-         *       - But there's an easy solution: replace all code in the dead block with
-         *         `nop; nop; ... nop; athrow`, making sure the bytecode size stays the same
-         *       - The corresponding stack frame can be easily generated: on entering a dead the block,
-         *         the frame requires a single Throwable on the stack.
-         *       - Since there are no branches to the dead block, the frame requirements are never violated.
-         *
-         * To summarize the above: it does matter what we emit after an ATHROW.
-         *
-         * NOW: if we end up here because we emitted a load of a (phantom) value of type Nothing$,
-         * there was no ATHROW emitted. So, we have to make the verifier happy and do something
-         * with that value. Since Nothing$ extends Throwable, the easiest is to just emit an ATHROW.
-         *
-         * If we ended up here because we generated a "throw e" expression, we know the last
-         * emitted instruction was an ATHROW. As explained above, it is OK to emit a second ATHROW,
-         * the verifiers will be happy.
-         */
-        if (lastInsn.getOpcode != asm.Opcodes.ATHROW)
-          emit(asm.Opcodes.ATHROW)
-      } else if (from.isNullType) {
-        /* After loading an expression of type `scala.runtime.Null$`, introduce POP; ACONST_NULL.
-         * This is required to pass the verifier: in Scala's type system, Null conforms to any
-         * reference type. In bytecode, the type Null is represented by scala.runtime.Null$, which
-         * is not a subtype of all reference types. Example:
-         *
-         *   def nl: Null = null // in bytecode, nl has return type scala.runtime.Null$
-         *   val a: String = nl  // OK for Scala but not for the JVM, scala.runtime.Null$ does not conform to String
-         *
-         * In order to fix the above problem, the value returned by nl is dropped and ACONST_NULL is
-         * inserted instead - after all, an expression of type scala.runtime.Null$ can only be null.
-         */
-        if (lastInsn.getOpcode != asm.Opcodes.ACONST_NULL) {
-          bc drop from
-          emit(asm.Opcodes.ACONST_NULL)
-        }
-      }
-      else (from, to) match  {
-        case (BYTE, LONG) | (SHORT, LONG) | (CHAR, LONG) | (INT, LONG) => bc.emitT2T(INT, LONG)
-        case _ => ()
-      }
-    }
-
-    /* Emit code to Load the qualifier of `tree` on top of the stack. */
-    def genLoadQualifier(tree: Tree): Unit = {
-      lineNumber(tree)
-      tree match {
-        case DesugaredSelect(qualifier, _) => genLoad(qualifier)
-        case t: Ident             => // dotty specific
-          cachedDesugarIdent(t) match {
-            case Some(sel) => genLoadQualifier(sel)
-            case None =>
-              assert(t.symbol.owner == this.claszSymbol)
-          }
-        case _                    => abort(s"Unknown qualifier $tree")
-      }
-    }
-
-    def genLoadArguments(args: List[Tree], btpes: List[BType]): Unit =
-      args match
-        case arg :: args1 =>
-          btpes match
-            case btpe :: btpes1 =>
-              genLoad(arg, btpe)
-              genLoadArguments(args1, btpes1)
-            case _ =>
-        case _ =>
-
-    def genLoadModule(tree: Tree): BType = {
-      val module = (
-        if (!tree.symbol.is(PackageClass)) tree.symbol
-        else tree.symbol.info.member(nme.PACKAGE).symbol match {
-          case NoSymbol => abort(s"SI-5604: Cannot use package as value: $tree")
-          case s        => abort(s"SI-5604: found package class where package object expected: $tree")
-        }
-      )
-      lineNumber(tree)
-      genLoadModule(module)
-      symInfoTK(module)
-    }
-
-    def genLoadModule(module: Symbol): Unit = {
-      def inStaticMethod = methSymbol != null && methSymbol.isStaticMember
-      if (claszSymbol == module.moduleClass && jMethodName != "readResolve" && !inStaticMethod) {
-        mnode.visitVarInsn(asm.Opcodes.ALOAD, 0)
-      } else {
-        val mbt = symInfoTK(module).asClassBType
-        mnode.visitFieldInsn(
-          asm.Opcodes.GETSTATIC,
-          mbt.internalName /* + "$" */ ,
-          str.MODULE_INSTANCE_FIELD,
-          mbt.descriptor // for nostalgics: toTypeKind(module.tpe).descriptor
-        )
-      }
-    }
-
-    def genConversion(from: BType, to: BType, cast: Boolean): Unit = {
-      if (cast) { bc.emitT2T(from, to) }
-      else {
-        bc drop from
-        bc boolconst (from == to)
-      }
-    }
-
-    def genCast(to: RefBType, cast: Boolean): Unit = {
-      if (cast) { bc checkCast  to }
-      else      { bc isInstance to }
-    }
-
-    /* Is the given symbol a primitive operation? */
-    def isPrimitive(fun: Tree): Boolean = {
-      primitives.isPrimitive(fun)
-    }
-
-    /* Generate coercion denoted by "code" */
-    def genCoercion(code: Int): Unit = {
-      import ScalaPrimitivesOps._
-      (code: @switch) match {
-        case B2B | S2S | C2C | I2I | L2L | F2F | D2D => ()
-        case _ =>
-          val from = coercionFrom(code)
-          val to   = coercionTo(code)
-          bc.emitT2T(from, to)
-      }
-    }
-
-    /* Generate string concatenation
-     *
-     * On JDK 8: create and append using `StringBuilder`
-     * On JDK 9+: use `invokedynamic` with `StringConcatFactory`
-     */
-    def genStringConcat(tree: Tree): BType = {
-      lineNumber(tree)
-      liftStringConcat(tree) match {
-        // Optimization for expressions of the form "" + x
-        case List(Literal(Constant("")), arg) =>
-          genLoad(arg, ObjectRef)
-          genCallMethod(defn.String_valueOf_Object, InvokeStyle.Static)
-
-        case concatenations =>
-          val concatArguments = concatenations.view
-            .filter {
-              case Literal(Constant("")) => false // empty strings are no-ops in concatenation
-              case _ => true
-            }
-            .map {
-              case Apply(boxOp, value :: Nil) if Erasure.Boxing.isBox(boxOp.symbol) && boxOp.symbol.denot.owner != defn.UnitModuleClass =>
-                // Eliminate boxing of primitive values. Boxing is introduced by erasure because
-                // there's only a single synthetic `+` method "added" to the string class.
-                value
-              case other => other
-            }
-            .toList
-
-          // `StringConcatFactory` only got added in JDK 9, so use `StringBuilder` for lower
-          if (classfileVersion < asm.Opcodes.V9) {
-
-            // Estimate capacity needed for the string builder
-            val approxBuilderSize = concatArguments.view.map {
-              case Literal(Constant(s: String)) => s.length
-              case Literal(c @ Constant(_)) if c.isNonUnitAnyVal => String.valueOf(c).length
-              case _ => 0
-            }.sum
-            bc.genNewStringBuilder(approxBuilderSize)
-
-            for (elem <- concatArguments) {
-              val elemType = tpeTK(elem)
-              genLoad(elem, elemType)
-              bc.genStringBuilderAppend(elemType)
-            }
-            bc.genStringBuilderEnd
-          } else {
-
-            /* `StringConcatFactory#makeConcatWithConstants` accepts max 200 argument slots. If
-             * the string concatenation is longer (unlikely), we spill into multiple calls
-             */
-            val MaxIndySlots = 200
-            val TagArg = '\u0001'    // indicates a hole (in the recipe string) for an argument
-            val TagConst = '\u0002'  // indicates a hole (in the recipe string) for a constant
-
-            val recipe = new StringBuilder()
-            val argTypes = Seq.newBuilder[asm.Type]
-            val constVals = Seq.newBuilder[String]
-            var totalArgSlots = 0
-            var countConcats = 1     // ie. 1 + how many times we spilled
-
-            for (elem <- concatArguments) {
-              val tpe = tpeTK(elem)
-              val elemSlots = tpe.size
-
-              // Unlikely spill case
-              if (totalArgSlots + elemSlots >= MaxIndySlots) {
-                bc.genIndyStringConcat(recipe.toString, argTypes.result(), constVals.result())
-                countConcats += 1
-                totalArgSlots = 0
-                recipe.setLength(0)
-                argTypes.clear()
-                constVals.clear()
-              }
-
-              elem match {
-                case Literal(Constant(s: String)) =>
-                  if (s.contains(TagArg) || s.contains(TagConst)) {
-                    totalArgSlots += elemSlots
-                    recipe.append(TagConst)
-                    constVals += s
-                  } else {
-                    recipe.append(s)
-                  }
-
-                case other =>
-                  totalArgSlots += elemSlots
-                  recipe.append(TagArg)
-                  val tpe = tpeTK(elem)
-                  argTypes += tpe.toASMType
-                  genLoad(elem, tpe)
-              }
-            }
-            bc.genIndyStringConcat(recipe.toString, argTypes.result(), constVals.result())
-
-            // If we spilled, generate one final concat
-            if (countConcats > 1) {
-              bc.genIndyStringConcat(
-                TagArg.toString * countConcats,
-                Seq.fill(countConcats)(StringRef.toASMType),
-                Seq.empty
-              )
-            }
-          }
-      }
-      StringRef
-    }
-
-    /**
-     * Generate a method invocation. If `specificReceiver != null`, it is used as receiver in the
-     * invocation instruction, otherwise `method.owner`. A specific receiver class is needed to
-     * prevent an IllegalAccessError, (aladdin bug 455).
-     */
-    def genCallMethod(method: Symbol, style: InvokeStyle, pos: Span = NoSpan, specificReceiver: Symbol = null): BType = {
-      val methodOwner = method.owner
-
-      // the class used in the invocation's method descriptor in the classfile
-      val receiverClass = {
-        if (specificReceiver != null)
-          assert(style.isVirtual || specificReceiver == methodOwner, s"specificReceiver can only be specified for virtual calls. $method - $specificReceiver")
-
-        val useSpecificReceiver = specificReceiver != null && !defn.isBottomClass(specificReceiver) && !method.isScalaStatic
-        val receiver = if (useSpecificReceiver) specificReceiver else methodOwner
-
-        // workaround for a JVM bug: https://bugs.openjdk.java.net/browse/JDK-8154587
-        // when an interface method overrides a member of Object (note that all interfaces implicitly
-        // have superclass Object), the receiver needs to be the interface declaring the override (and
-        // not a sub-interface that inherits it). example:
-        //   trait T { override def clone(): Object = "" }
-        //   trait U extends T
-        //   class C extends U
-        //   class D { def f(u: U) = u.clone() }
-        // The invocation `u.clone()` needs `T` as a receiver:
-        //   - using Object is illegal, as Object.clone is protected
-        //   - using U results in a `NoSuchMethodError: U.clone. This is the JVM bug.
-        // Note that a mixin forwarder is generated, so the correct method is executed in the end:
-        //   class C { override def clone(): Object = super[T].clone() }
-        val isTraitMethodOverridingObjectMember = {
-          receiver != methodOwner && // fast path - the boolean is used to pick either of these two, if they are the same it does not matter
-            style.isVirtual &&
-            isEmittedInterface(receiver) &&
-            defn.ObjectType.decl(method.name).symbol.exists && { // fast path - compute overrideChain on the next line only if necessary
-              val syms = method.allOverriddenSymbols.toList
-              !syms.isEmpty && syms.last.owner == defn.ObjectClass
-            }
-        }
-        if (isTraitMethodOverridingObjectMember) methodOwner else receiver
-      }
-
-      receiverClass.info // ensure types the type is up to date; erasure may add lateINTERFACE to traits
-      val receiverName = internalName(receiverClass)
-
-      val jname    = method.javaSimpleName
-      val bmType   = asmMethodType(method)
-      val mdescr   = bmType.descriptor
-
-      val isInterface = isEmittedInterface(receiverClass)
-      import InvokeStyle._
-      if (style == Super) {
-        if (isInterface && !method.is(JavaDefined)) {
-          val args = new Array[BType](bmType.argumentTypes.length + 1)
-          val ownerBType = toTypeKind(method.owner.info)
-          bmType.argumentTypes.copyToArray(args, 1)
-          val staticDesc = MethodBType(ownerBType :: bmType.argumentTypes, bmType.returnType).descriptor
-          val staticName = traitSuperAccessorName(method)
-          bc.invokestatic(receiverName, staticName, staticDesc, isInterface)
-        } else {
-          bc.invokespecial(receiverName, jname, mdescr, isInterface)
-        }
-      } else {
-        val opc = style match {
-          case Static => Opcodes.INVOKESTATIC
-          case Special => Opcodes.INVOKESPECIAL
-          case Virtual => if (isInterface) Opcodes.INVOKEINTERFACE else Opcodes.INVOKEVIRTUAL
-        }
-        bc.emitInvoke(opc, receiverName, jname, mdescr, isInterface)
-      }
-
-      bmType.returnType
-    } // end of genCallMethod()
-
-    /* Generate the scala ## method. */
-    def genScalaHash(tree: Tree): BType = {
-      genLoad(tree, ObjectRef)
-      genCallMethod(NoSymbol, InvokeStyle.Static) // used to dispatch ## on primitives to ScalaRuntime.hash. Should be implemented by a miniphase
-    }
-
-    /*
-     * Returns a list of trees that each should be concatenated, from left to right.
-     * It turns a chained call like "a".+("b").+("c") into a list of arguments.
-     */
-    def liftStringConcat(tree: Tree): List[Tree] = tree match {
-      case tree @ Apply(fun @ DesugaredSelect(larg, method), rarg) =>
-        if (isPrimitive(fun) &&
-            primitives.getPrimitive(tree, larg.tpe) == ScalaPrimitivesOps.CONCAT)
-          liftStringConcat(larg) ::: rarg
-        else
-          tree :: Nil
-      case _ =>
-        tree :: Nil
-    }
-
-    /* Emit code to compare the two top-most stack values using the 'op' operator. */
-    private def genCJUMP(success: asm.Label, failure: asm.Label, op: TestOp, tk: BType, targetIfNoJump: asm.Label, negated: Boolean = false): Unit = {
-      if (targetIfNoJump == success) genCJUMP(failure, success, op.negate(), tk, targetIfNoJump, negated = !negated)
-      else {
-        if (tk.isIntSizedType) { // BOOL, BYTE, CHAR, SHORT, or INT
-          bc.emitIF_ICMP(op, success)
-        } else if (tk.isRef) { // REFERENCE(_) | ARRAY(_)
-          bc.emitIF_ACMP(op, success)
-        } else {
-          import Primitives._
-          def useCmpG = if (negated) op == GT || op == GE else op == LT || op == LE
-          (tk: @unchecked) match {
-            case LONG   => emit(asm.Opcodes.LCMP)
-            case FLOAT  => emit(if (useCmpG) asm.Opcodes.FCMPG else asm.Opcodes.FCMPL)
-            case DOUBLE => emit(if (useCmpG) asm.Opcodes.DCMPG else asm.Opcodes.DCMPL)
-          }
-          bc.emitIF(op, success)
-        }
-        if (targetIfNoJump != failure) bc goTo failure
-      }
-    }
-
-    /* Emits code to compare (and consume) stack-top and zero using the 'op' operator */
-    private def genCZJUMP(success: asm.Label, failure: asm.Label, op: TestOp, tk: BType, targetIfNoJump: asm.Label, negated: Boolean = false): Unit = {
-      import Primitives._
-      if (targetIfNoJump == success) genCZJUMP(failure, success, op.negate(), tk, targetIfNoJump, negated = !negated)
-      else {
-        if (tk.isIntSizedType) { // BOOL, BYTE, CHAR, SHORT, or INT
-          bc.emitIF(op, success)
-        } else if (tk.isRef) { // REFERENCE(_) | ARRAY(_)
-          (op: @unchecked) match { // references are only compared with EQ and NE
-            case EQ => bc emitIFNULL    success
-            case NE => bc emitIFNONNULL success
-          }
-        } else {
-          def useCmpG = if (negated) op == GT || op == GE else op == LT || op == LE
-          (tk: @unchecked) match {
-            case LONG   =>
-              emit(asm.Opcodes.LCONST_0)
-              emit(asm.Opcodes.LCMP)
-            case FLOAT  =>
-              emit(asm.Opcodes.FCONST_0)
-              emit(if (useCmpG) asm.Opcodes.FCMPG else asm.Opcodes.FCMPL)
-            case DOUBLE =>
-              emit(asm.Opcodes.DCONST_0)
-              emit(if (useCmpG) asm.Opcodes.DCMPG else asm.Opcodes.DCMPL)
-          }
-          bc.emitIF(op, success)
-        }
-        if (targetIfNoJump != failure) bc goTo failure
-      }
-    }
-
-    def testOpForPrimitive(primitiveCode: Int) = (primitiveCode: @switch) match {
-       case ScalaPrimitivesOps.ID => Primitives.EQ
-       case ScalaPrimitivesOps.NI => Primitives.NE
-       case ScalaPrimitivesOps.EQ => Primitives.EQ
-       case ScalaPrimitivesOps.NE => Primitives.NE
-       case ScalaPrimitivesOps.LT => Primitives.LT
-       case ScalaPrimitivesOps.LE => Primitives.LE
-       case ScalaPrimitivesOps.GT => Primitives.GT
-       case ScalaPrimitivesOps.GE => Primitives.GE
-     }
-
-    /*
-     * Generate code for conditional expressions.
-     * The jump targets success/failure of the test are `then-target` and `else-target` resp.
-     */
-    private def genCond(tree: Tree, success: asm.Label, failure: asm.Label, targetIfNoJump: asm.Label): Unit = {
-
-      def genComparisonOp(l: Tree, r: Tree, code: Int): Unit = {
-        val op = testOpForPrimitive(code)
-        def isNull(t: Tree): Boolean = t match {
-          case Literal(Constant(null)) => true
-          case _ => false
-        }
-        def ifOneIsNull(l: Tree, r: Tree): Tree = if (isNull(l)) r else if (isNull(r)) l else null
-        val nonNullSide = if (ScalaPrimitivesOps.isReferenceEqualityOp(code)) ifOneIsNull(l, r) else null
-        if (nonNullSide != null) {
-          // special-case reference (in)equality test for null (null eq x, x eq null)
-          genLoad(nonNullSide, ObjectRef)
-          genCZJUMP(success, failure, op, ObjectRef, targetIfNoJump)
-        } else {
-          val tk = tpeTK(l).maxType(tpeTK(r))
-          genLoad(l, tk)
-          genLoad(r, tk)
-          genCJUMP(success, failure, op, tk, targetIfNoJump)
-        }
-      }
-
-      def loadAndTestBoolean() = {
-        genLoad(tree, BOOL)
-        genCZJUMP(success, failure, Primitives.NE, BOOL, targetIfNoJump)
-      }
-
-      lineNumber(tree)
-      tree match {
-
-        case tree @ Apply(fun, args) if primitives.isPrimitive(fun.symbol) =>
-          import ScalaPrimitivesOps.{ ZNOT, ZAND, ZOR, EQ }
-
-          // lhs and rhs of test
-          lazy val DesugaredSelect(lhs, _) = fun: @unchecked
-          val rhs = if (args.isEmpty) tpd.EmptyTree else args.head // args.isEmpty only for ZNOT
-
-          def genZandOrZor(and: Boolean): Unit = {
-            // reaching "keepGoing" indicates the rhs should be evaluated too (ie not short-circuited).
-            val keepGoing = new asm.Label
-
-            if (and) genCond(lhs, keepGoing, failure, targetIfNoJump = keepGoing)
-            else     genCond(lhs, success,   keepGoing, targetIfNoJump = keepGoing)
-
-            markProgramPoint(keepGoing)
-            genCond(rhs, success, failure, targetIfNoJump)
-          }
-
-          primitives.getPrimitive(fun.symbol) match {
-            case ZNOT   => genCond(lhs, failure, success, targetIfNoJump)
-            case ZAND   => genZandOrZor(and = true)
-            case ZOR    => genZandOrZor(and = false)
-            case code   =>
-              if (ScalaPrimitivesOps.isUniversalEqualityOp(code) && tpeTK(lhs).isClass) {
-                // rewrite `==` to null tests and `equals`. not needed for arrays (`equals` is reference equality).
-                if (code == EQ) genEqEqPrimitive(lhs, rhs, success, failure, targetIfNoJump)
-                else            genEqEqPrimitive(lhs, rhs, failure, success, targetIfNoJump)
-              } else if (ScalaPrimitivesOps.isComparisonOp(code)) {
-                genComparisonOp(lhs, rhs, code)
-              } else
-                loadAndTestBoolean()
-          }
-
-        case Block(stats, expr) =>
-          /* Push the decision further down the `expr`.
-           * This is particularly effective for the shape of do..while loops.
-           */
-          val savedScope = varsInScope
-          varsInScope = Nil
-          stats foreach genStat
-          genCond(expr, success, failure, targetIfNoJump)
-          emitLocalVarScopes()
-          varsInScope = savedScope
-
-        case If(condp, thenp, elsep) =>
-          val innerSuccess = new asm.Label
-          val innerFailure = new asm.Label
-          genCond(condp, innerSuccess, innerFailure, targetIfNoJump = innerSuccess)
-          markProgramPoint(innerSuccess)
-          genCond(thenp, success, failure, targetIfNoJump = innerFailure)
-          markProgramPoint(innerFailure)
-          genCond(elsep, success, failure, targetIfNoJump)
-
-        case _ => loadAndTestBoolean()
-      }
-
-    } // end of genCond()
-
-    /*
-     * Generate the "==" code for object references. It is equivalent of
-     * if (l eq null) r eq null else l.equals(r);
-     *
-     * @param l       left-hand-side  of the '=='
-     * @param r       right-hand-side of the '=='
-     */
-    def genEqEqPrimitive(l: Tree, r: Tree, success: asm.Label, failure: asm.Label, targetIfNoJump: asm.Label): Unit = {
-
-      /* True if the equality comparison is between values that require the use of the rich equality
-       * comparator (scala.runtime.Comparator.equals). This is the case when either side of the
-       * comparison might have a run-time type subtype of java.lang.Number or java.lang.Character.
-       * When it is statically known that both sides are equal and subtypes of Number of Character,
-       * not using the rich equality is possible (their own equals method will do ok.)
-       */
-      val mustUseAnyComparator: Boolean = {
-        val areSameFinals = l.tpe.typeSymbol.is(Final) && r.tpe.typeSymbol.is(Final) && (l.tpe =:= r.tpe)
-        // todo: remove
-        def isMaybeBoxed(sym: Symbol): Boolean = {
-          (sym == defn.ObjectClass) ||
-            (sym == defn.JavaSerializableClass) ||
-            (sym == defn.ComparableClass) ||
-            (sym derivesFrom defn.BoxedNumberClass) ||
-            (sym derivesFrom defn.BoxedCharClass) ||
-            (sym derivesFrom defn.BoxedBooleanClass)
-        }
-        !areSameFinals && isMaybeBoxed(l.tpe.typeSymbol) && isMaybeBoxed(r.tpe.typeSymbol)
-      }
-      def isNull(t: Tree): Boolean = t match {
-        case Literal(Constant(null)) => true
-        case _ => false
-      }
-      def isNonNullExpr(t: Tree): Boolean = t.isInstanceOf[Literal] || ((t.symbol ne null) && t.symbol.is(Module))
-
-      if (mustUseAnyComparator) {
-        val equalsMethod: Symbol = {
-          if (l.tpe <:< defn.BoxedNumberClass.info) {
-            if (r.tpe <:< defn.BoxedNumberClass.info) defn.BoxesRunTimeModule.requiredMethod(nme.equalsNumNum)
-            else if (r.tpe <:< defn.BoxedCharClass.info) defn.BoxesRunTimeModule.requiredMethod(nme.equalsNumChar)
-            else defn.BoxesRunTimeModule.requiredMethod(nme.equalsNumObject)
-          } else defn.BoxesRunTimeModule_externalEquals
-        }
-
-        genLoad(l, ObjectRef)
-        genLoad(r, ObjectRef)
-        genCallMethod(equalsMethod, InvokeStyle.Static)
-        genCZJUMP(success, failure, Primitives.NE, BOOL, targetIfNoJump)
-      }
-      else {
-        if (isNull(l)) {
-          // null == expr -> expr eq null
-          genLoad(r, ObjectRef)
-          genCZJUMP(success, failure, Primitives.EQ, ObjectRef, targetIfNoJump)
-        } else if (isNull(r)) {
-          // expr == null -> expr eq null
-          genLoad(l, ObjectRef)
-          genCZJUMP(success, failure, Primitives.EQ, ObjectRef, targetIfNoJump)
-        } else if (isNonNullExpr(l)) {
-          // SI-7852 Avoid null check if L is statically non-null.
-          genLoad(l, ObjectRef)
-          genLoad(r, ObjectRef)
-          genCallMethod(defn.Any_equals, InvokeStyle.Virtual)
-          genCZJUMP(success, failure, Primitives.NE, BOOL, targetIfNoJump)
-        } else {
-          // l == r -> if (l eq null) r eq null else l.equals(r)
-          val eqEqTempLocal = locals.makeLocal(ObjectRef, nme.EQEQ_LOCAL_VAR.mangledString, defn.ObjectType, r.span)
-          val lNull    = new asm.Label
-          val lNonNull = new asm.Label
-
-          genLoad(l, ObjectRef)
-          genLoad(r, ObjectRef)
-          locals.store(eqEqTempLocal)
-          bc dup ObjectRef
-          genCZJUMP(lNull, lNonNull, Primitives.EQ, ObjectRef, targetIfNoJump = lNull)
-
-          markProgramPoint(lNull)
-          bc drop ObjectRef
-          locals.load(eqEqTempLocal)
-          genCZJUMP(success, failure, Primitives.EQ, ObjectRef, targetIfNoJump = lNonNull)
-
-          markProgramPoint(lNonNull)
-          locals.load(eqEqTempLocal)
-          genCallMethod(defn.Any_equals, InvokeStyle.Virtual)
-          genCZJUMP(success, failure, Primitives.NE, BOOL, targetIfNoJump)
-        }
-      }
-    }
-
-
-    def genSynchronized(tree: Apply, expectedType: BType): BType
-    def genLoadTry(tree: Try): BType
-
-    def genInvokeDynamicLambda(ctor: Symbol, lambdaTarget: Symbol, environmentSize: Int, functionalInterface: Symbol): BType = {
-      import java.lang.invoke.LambdaMetafactory.{FLAG_BRIDGES, FLAG_SERIALIZABLE}
-
-      report.debuglog(s"Using invokedynamic rather than `new ${ctor.owner}`")
-      val generatedType = classBTypeFromSymbol(functionalInterface)
-      // Lambdas should be serializable if they implement a SAM that extends Serializable or if they
-      // implement a scala.Function* class.
-      val isSerializable = functionalInterface.isSerializable || defn.isFunctionClass(functionalInterface)
-      val isInterface = isEmittedInterface(lambdaTarget.owner)
-      val invokeStyle =
-        if (lambdaTarget.isStaticMember) asm.Opcodes.H_INVOKESTATIC
-        else if (lambdaTarget.is(Private) || lambdaTarget.isClassConstructor) asm.Opcodes.H_INVOKESPECIAL
-        else if (isInterface) asm.Opcodes.H_INVOKEINTERFACE
-        else asm.Opcodes.H_INVOKEVIRTUAL
-
-      val targetHandle =
-        new asm.Handle(invokeStyle,
-          classBTypeFromSymbol(lambdaTarget.owner).internalName,
-          lambdaTarget.javaSimpleName,
-          asmMethodType(lambdaTarget).descriptor,
-          /* itf = */ isInterface)
-
-      val (a,b) = lambdaTarget.info.firstParamTypes.splitAt(environmentSize)
-      var (capturedParamsTypes, lambdaParamTypes) = (a,b)
-
-      if (invokeStyle != asm.Opcodes.H_INVOKESTATIC) capturedParamsTypes = lambdaTarget.owner.info :: capturedParamsTypes
-
-      // Requires https://github.com/scala/scala-java8-compat on the runtime classpath
-      val returnUnit = lambdaTarget.info.resultType.typeSymbol == defn.UnitClass
-      val functionalInterfaceDesc: String = generatedType.descriptor
-      val desc = capturedParamsTypes.map(tpe => toTypeKind(tpe)).mkString(("("), "", ")") + functionalInterfaceDesc
-      // TODO specialization
-      val instantiatedMethodType = new MethodBType(lambdaParamTypes.map(p => toTypeKind(p)), toTypeKind(lambdaTarget.info.resultType)).toASMType
-
-      val samMethod = atPhase(erasurePhase) {
-        val samMethods = toDenot(functionalInterface).info.possibleSamMethods.toList
-        samMethods match {
-          case x :: Nil => x.symbol
-          case Nil => abort(s"${functionalInterface.show} is not a functional interface. It doesn't have abstract methods")
-          case xs => abort(s"${functionalInterface.show} is not a functional interface. " +
-            s"It has the following abstract methods: ${xs.map(_.name).mkString(", ")}")
-        }
-      }
-
-      val methodName = samMethod.javaSimpleName
-      val samMethodType = asmMethodType(samMethod).toASMType
-      // scala/bug#10334: make sure that a lambda object for `T => U` has a method `apply(T)U`, not only the `(Object)Object`
-      // version. Using the lambda a structural type `{def apply(t: T): U}` causes a reflective lookup for this method.
-      val needsGenericBridge = samMethodType != instantiatedMethodType
-      val bridgeMethods = atPhase(erasurePhase){
-        samMethod.allOverriddenSymbols.toList
-      }
-      val overriddenMethodTypes = bridgeMethods.map(b => asmMethodType(b).toASMType)
-
-      // any methods which `samMethod` overrides need bridges made for them
-      // this is done automatically during erasure for classes we generate, but LMF needs to have them explicitly mentioned
-      // so we have to compute them at this relatively late point.
-      val bridgeTypes = (
-        if (needsGenericBridge)
-          instantiatedMethodType +: overriddenMethodTypes
-        else
-          overriddenMethodTypes
-      ).distinct.filterNot(_ == samMethodType)
-
-      val needsBridges = bridgeTypes.nonEmpty
-
-      def flagIf(b: Boolean, flag: Int): Int = if (b) flag else 0
-      val flags = flagIf(isSerializable, FLAG_SERIALIZABLE) | flagIf(needsBridges, FLAG_BRIDGES)
-
-      val bsmArgs0 = Seq(samMethodType, targetHandle, instantiatedMethodType)
-      val bsmArgs1 = if (flags != 0) Seq(Int.box(flags)) else Seq.empty
-      val bsmArgs2 = if needsBridges then bridgeTypes.length +: bridgeTypes else Seq.empty
-
-      val bsmArgs = bsmArgs0 ++ bsmArgs1 ++ bsmArgs2
-
-      val metafactory =
-        if (flags != 0)
-          jliLambdaMetaFactoryAltMetafactoryHandle // altMetafactory required to be able to pass the flags and additional arguments if needed
-        else
-          jliLambdaMetaFactoryMetafactoryHandle
-
-      bc.jmethod.visitInvokeDynamicInsn(methodName, desc, metafactory, bsmArgs: _*)
-
-      generatedType
-    }
-  }
-
-  /** Does this symbol actually correspond to an interface that will be emitted?
-   *  In the backend, this should be preferred over `isInterface` because it
-   *  also returns true for the symbols of the fake companion objects we
-   *  create for Java-defined classes as well as for Java annotations
-   *  which we represent as classes.
-   */
-  private def isEmittedInterface(sym: Symbol): Boolean = sym.isInterface ||
-    sym.is(JavaDefined) && (toDenot(sym).isAnnotation || sym.is(ModuleClass) && (sym.companionClass.is(PureInterface)) || sym.companionClass.is(Trait))
-
-
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/BCodeHelpers.scala b/tests/pos-with-compiler-cc/backend/jvm/BCodeHelpers.scala
deleted file mode 100644
index 5ad6a99f6055..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/BCodeHelpers.scala
+++ /dev/null
@@ -1,960 +0,0 @@
-package dotty.tools
-package backend
-package jvm
-
-import scala.language.unsafeNulls
-
-import scala.annotation.threadUnsafe
-import scala.tools.asm
-import scala.tools.asm.AnnotationVisitor
-import scala.tools.asm.ClassWriter
-import scala.collection.mutable
-
-import dotty.tools.dotc.CompilationUnit
-import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.ast.Trees
-import dotty.tools.dotc.core.Annotations._
-import dotty.tools.dotc.core.Constants._
-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.Names.Name
-import dotty.tools.dotc.core.NameKinds.ExpandedName
-import dotty.tools.dotc.core.Signature
-import dotty.tools.dotc.core.StdNames._
-import dotty.tools.dotc.core.NameKinds
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.core.Types
-import dotty.tools.dotc.core.Types._
-import dotty.tools.dotc.core.TypeErasure
-import dotty.tools.dotc.transform.GenericSignatures
-import dotty.tools.dotc.transform.ElimErasedValueType
-import dotty.tools.io.AbstractFile
-import dotty.tools.dotc.report
-
-import dotty.tools.backend.jvm.DottyBackendInterface.symExtensions
-
-/*
- *  Traits encapsulating functionality to convert Scala AST Trees into ASM ClassNodes.
- *
- *  @author  Miguel Garcia, http://lamp.epfl.ch/~magarcia/ScalaCompilerCornerReloaded
- *  @version 1.0
- *
- */
-trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
-  // for some reason singleton types aren't allowed in constructor calls. will need several casts in code to enforce
-
-  //import global._
-  //import bTypes._
-  //import coreBTypes._
-  import bTypes._
-  import tpd._
-  import coreBTypes._
-  import int.{_, given}
-  import DottyBackendInterface._
-
-  def ScalaATTRName: String = "Scala"
-  def ScalaSignatureATTRName: String = "ScalaSig"
-
-  @threadUnsafe lazy val AnnotationRetentionAttr: ClassSymbol = requiredClass("java.lang.annotation.Retention")
-  @threadUnsafe lazy val AnnotationRetentionSourceAttr: TermSymbol = requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("SOURCE")
-  @threadUnsafe lazy val AnnotationRetentionClassAttr: TermSymbol = requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("CLASS")
-  @threadUnsafe lazy val AnnotationRetentionRuntimeAttr: TermSymbol = requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("RUNTIME")
-
-  val bCodeAsmCommon: BCodeAsmCommon[int.type] = new BCodeAsmCommon(int)
-
-  /*
-   * must-single-thread
-   */
-  def getFileForClassfile(base: AbstractFile, clsName: String, suffix: String): AbstractFile = {
-    getFile(base, clsName, suffix)
-  }
-
-  /*
-   * must-single-thread
-   */
-  def getOutFolder(csym: Symbol, cName: String): AbstractFile = {
-    try {
-      outputDirectory
-    } catch {
-      case ex: Throwable =>
-        report.error(em"Couldn't create file for class $cName\n${ex.getMessage}", ctx.source.atSpan(csym.span))
-        null
-    }
-  }
-
-  final def traitSuperAccessorName(sym: Symbol): String = {
-    val nameString = sym.javaSimpleName.toString
-    if (sym.name == nme.TRAIT_CONSTRUCTOR) nameString
-    else nameString + "$"
-  }
-
-  // -----------------------------------------------------------------------------------------
-  // finding the least upper bound in agreement with the bytecode verifier (given two internal names handed by ASM)
-  // Background:
-  //  http://gallium.inria.fr/~xleroy/publi/bytecode-verification-JAR.pdf
-  //  http://comments.gmane.org/gmane.comp.java.vm.languages/2293
-  //  https://issues.scala-lang.org/browse/SI-3872
-  // -----------------------------------------------------------------------------------------
-
-  /*  An `asm.ClassWriter` that uses `jvmWiseLUB()`
-   *  The internal name of the least common ancestor of the types given by inameA and inameB.
-   *  It's what ASM needs to know in order to compute stack map frames, http://asm.ow2.org/doc/developer-guide.html#controlflow
-   */
-  final class CClassWriter(flags: Int) extends asm.ClassWriter(flags) {
-
-    /**
-     * This method is thread-safe: it depends only on the BTypes component, which does not depend
-     * on global. TODO @lry move to a different place where no global is in scope, on bTypes.
-     */
-    override def getCommonSuperClass(inameA: String, inameB: String): String = {
-      val a = classBTypeFromInternalName(inameA)
-      val b = classBTypeFromInternalName(inameB)
-      val lub = a.jvmWiseLUB(b)
-      val lubName = lub.internalName
-      assert(lubName != "scala/Any")
-      lubName // ASM caches the answer during the lifetime of a ClassWriter. We outlive that. Not sure whether caching on our side would improve things.
-    }
-  }
-
-  /*
-   * must-single-thread
-   */
-  def initBytecodeWriter(): BytecodeWriter = {
-    (None: Option[AbstractFile] /*getSingleOutput*/) match { // todo: implement
-      case Some(f) if f.hasExtension("jar") =>
-        new DirectToJarfileWriter(f.file)
-      case _ =>
-        factoryNonJarBytecodeWriter()
-    }
-  }
-
-  /*
-   * Populates the InnerClasses JVM attribute with `refedInnerClasses`. See also the doc on inner
-   * classes in BTypes.scala.
-   *
-   * `refedInnerClasses` may contain duplicates, need not contain the enclosing inner classes of
-   * each inner class it lists (those are looked up and included).
-   *
-   * This method serializes in the InnerClasses JVM attribute in an appropriate order,
-   * not necessarily that given by `refedInnerClasses`.
-   *
-   * can-multi-thread
-   */
-  final def addInnerClasses(jclass: asm.ClassVisitor, declaredInnerClasses: List[ClassBType], refedInnerClasses: List[ClassBType]): Unit = {
-    // sorting ensures nested classes are listed after their enclosing class thus satisfying the Eclipse Java compiler
-    val allNestedClasses = new mutable.TreeSet[ClassBType]()(Ordering.by(_.internalName))
-    allNestedClasses ++= declaredInnerClasses
-    refedInnerClasses.foreach(allNestedClasses ++= _.enclosingNestedClassesChain)
-    for nestedClass <- allNestedClasses
-    do {
-      // Extract the innerClassEntry - we know it exists, enclosingNestedClassesChain only returns nested classes.
-      val Some(e) = nestedClass.innerClassAttributeEntry: @unchecked
-      jclass.visitInnerClass(e.name, e.outerName, e.innerName, e.flags)
-    }
-  }
-
-  /*
-   * can-multi-thread
-   */
-  def createJAttribute(name: String, b: Array[Byte], offset: Int, len: Int): asm.Attribute = {
-    new asm.Attribute(name) {
-      override def write(classWriter: ClassWriter, code: Array[Byte],
-        codeLength: Int, maxStack: Int, maxLocals: Int): asm.ByteVector = {
-        val byteVector = new asm.ByteVector(len)
-        byteVector.putByteArray(b, offset, len)
-        byteVector
-      }
-    }
-  }
-
-  /*
-   * Custom attribute (JVMS 4.7.1) "ScalaSig" used as marker only
-   * i.e., the pickle is contained in a custom annotation, see:
-   *   (1) `addAnnotations()`,
-   *   (2) SID # 10 (draft) - Storage of pickled Scala signatures in class files, http://www.scala-lang.org/sid/10
-   *   (3) SID # 5 - Internals of Scala Annotations, http://www.scala-lang.org/sid/5
-   * That annotation in turn is not related to the "java-generic-signature" (JVMS 4.7.9)
-   * other than both ending up encoded as attributes (JVMS 4.7)
-   * (with the caveat that the "ScalaSig" attribute is associated to some classes,
-   * while the "Signature" attribute can be associated to classes, methods, and fields.)
-   *
-   */
-  trait BCPickles {
-
-    import dotty.tools.dotc.core.unpickleScala2.{ PickleFormat, PickleBuffer }
-
-    val versionPickle = {
-      val vp = new PickleBuffer(new Array[Byte](16), -1, 0)
-      assert(vp.writeIndex == 0, vp)
-      vp writeNat PickleFormat.MajorVersion
-      vp writeNat PickleFormat.MinorVersion
-      vp writeNat 0
-      vp
-    }
-
-    /*
-     * can-multi-thread
-     */
-    def pickleMarkerLocal = {
-      createJAttribute(ScalaSignatureATTRName, versionPickle.bytes, 0, versionPickle.writeIndex)
-    }
-
-    /*
-     * can-multi-thread
-     */
-    def pickleMarkerForeign = {
-      createJAttribute(ScalaATTRName, new Array[Byte](0), 0, 0)
-    }
-  } // end of trait BCPickles
-
-  trait BCInnerClassGen extends Pure {
-
-    def debugLevel = 3 // 0 -> no debug info; 1-> filename; 2-> lines; 3-> varnames
-
-    final val emitSource = debugLevel >= 1
-    final val emitLines  = debugLevel >= 2
-    final val emitVars   = debugLevel >= 3
-
-    /**
-     * The class internal name for a given class symbol.
-     */
-    final def internalName(sym: Symbol): String = {
-      // For each java class, the scala compiler creates a class and a module (thus a module class).
-      // If the `sym` is a java module class, we use the java class instead. This ensures that the
-      // ClassBType is created from the main class (instead of the module class).
-      // The two symbols have the same name, so the resulting internalName is the same.
-      val classSym = if (sym.is(JavaDefined) && sym.is(ModuleClass)) sym.linkedClass else sym
-      getClassBType(classSym).internalName
-    }
-
-    private def assertClassNotArray(sym: Symbol): Unit = {
-      assert(sym.isClass, sym)
-      assert(sym != defn.ArrayClass || compilingArray, sym)
-    }
-
-    private def assertClassNotArrayNotPrimitive(sym: Symbol): Unit = {
-      assertClassNotArray(sym)
-      assert(!primitiveTypeMap.contains(sym) || isCompilingPrimitive, sym)
-    }
-
-    /**
-     * The ClassBType for a class symbol.
-     *
-     * The class symbol scala.Nothing is mapped to the class scala.runtime.Nothing$. Similarly,
-     * scala.Null is mapped to scala.runtime.Null$. This is because there exist no class files
-     * for the Nothing / Null. If used for example as a parameter type, we use the runtime classes
-     * in the classfile method signature.
-     *
-     * Note that the referenced class symbol may be an implementation class. For example when
-     * compiling a mixed-in method that forwards to the static method in the implementation class,
-     * the class descriptor of the receiver (the implementation class) is obtained by creating the
-     * ClassBType.
-     */
-    final def getClassBType(sym: Symbol): ClassBType = {
-      assertClassNotArrayNotPrimitive(sym)
-
-      if (sym == defn.NothingClass) srNothingRef
-      else if (sym == defn.NullClass) srNullRef
-      else classBTypeFromSymbol(sym)
-    }
-
-    /*
-     * must-single-thread
-     */
-    final def asmMethodType(msym: Symbol): MethodBType = {
-      assert(msym.is(Method), s"not a method-symbol: $msym")
-      val resT: BType =
-        if (msym.isClassConstructor || msym.isConstructor) UNIT
-        else toTypeKind(msym.info.resultType)
-      MethodBType(msym.info.firstParamTypes map toTypeKind, resT)
-    }
-
-    /**
-     * The jvm descriptor of a type.
-     */
-    final def typeDescriptor(t: Type): String = { toTypeKind(t).descriptor   }
-
-    /**
-     * The jvm descriptor for a symbol.
-     */
-    final def symDescriptor(sym: Symbol): String = getClassBType(sym).descriptor
-
-    final def toTypeKind(tp: Type): BType = typeToTypeKind(tp)(BCodeHelpers.this)(this)
-
-  } // end of trait BCInnerClassGen
-
-  trait BCAnnotGen extends BCInnerClassGen {
-
-    /*
-     * must-single-thread
-     */
-    def emitAnnotations(cw: asm.ClassVisitor, annotations: List[Annotation]): Unit =
-      for(annot <- annotations; if shouldEmitAnnotation(annot)) {
-        val typ = annot.tree.tpe
-        val assocs = assocsFromApply(annot.tree)
-        val av = cw.visitAnnotation(typeDescriptor(typ), isRuntimeVisible(annot))
-        emitAssocs(av, assocs, BCodeHelpers.this)(this)
-      }
-
-    /*
-     * must-single-thread
-     */
-    def emitAnnotations(mw: asm.MethodVisitor, annotations: List[Annotation]): Unit =
-      for(annot <- annotations; if shouldEmitAnnotation(annot)) {
-        val typ = annot.tree.tpe
-        val assocs = assocsFromApply(annot.tree)
-        val av = mw.visitAnnotation(typeDescriptor(typ), isRuntimeVisible(annot))
-        emitAssocs(av, assocs, BCodeHelpers.this)(this)
-      }
-
-    /*
-     * must-single-thread
-     */
-    def emitAnnotations(fw: asm.FieldVisitor, annotations: List[Annotation]): Unit =
-      for(annot <- annotations; if shouldEmitAnnotation(annot)) {
-        val typ = annot.tree.tpe
-        val assocs = assocsFromApply(annot.tree)
-        val av = fw.visitAnnotation(typeDescriptor(typ), isRuntimeVisible(annot))
-        emitAssocs(av, assocs, BCodeHelpers.this)(this)
-      }
-
-    /*
-     * must-single-thread
-     */
-    def emitParamNames(jmethod: asm.MethodVisitor, params: List[Symbol]) =
-      for param <- params do
-        var access = asm.Opcodes.ACC_FINAL
-        if param.is(Artifact) then access |= asm.Opcodes.ACC_SYNTHETIC
-        jmethod.visitParameter(param.name.mangledString, access)
-
-    /*
-     * must-single-thread
-     */
-    def emitParamAnnotations(jmethod: asm.MethodVisitor, pannotss: List[List[Annotation]]): Unit =
-      val annotationss = pannotss map (_ filter shouldEmitAnnotation)
-      if (annotationss forall (_.isEmpty)) return
-      for ((annots, idx) <- annotationss.zipWithIndex;
-        annot <- annots) {
-        val typ = annot.tree.tpe
-        val assocs = assocsFromApply(annot.tree)
-        val pannVisitor: asm.AnnotationVisitor = jmethod.visitParameterAnnotation(idx, typeDescriptor(typ.asInstanceOf[Type]), isRuntimeVisible(annot))
-        emitAssocs(pannVisitor, assocs, BCodeHelpers.this)(this)
-      }
-
-
-    private def shouldEmitAnnotation(annot: Annotation): Boolean = {
-      annot.symbol.is(JavaDefined) &&
-        retentionPolicyOf(annot) != AnnotationRetentionSourceAttr
-    }
-
-    private def emitAssocs(av: asm.AnnotationVisitor, assocs: List[(Name, Object)], bcodeStore: BCodeHelpers)
-        (innerClasesStore: bcodeStore.BCInnerClassGen) = {
-      for ((name, value) <- assocs)
-        emitArgument(av, name.mangledString, value.asInstanceOf[Tree], bcodeStore)(innerClasesStore)
-      av.visitEnd()
-    }
-
-    private def emitArgument(av:   AnnotationVisitor,
-                           name: String,
-                           arg:  Tree, bcodeStore: BCodeHelpers)(innerClasesStore: bcodeStore.BCInnerClassGen): Unit = {
-      val narg = normalizeArgument(arg)
-      // Transformation phases are not run on annotation trees, so we need to run
-      // `constToLiteral` at this point.
-      val t = atPhase(erasurePhase)(constToLiteral(narg))
-      t match {
-        case Literal(const @ Constant(_)) =>
-          const.tag match {
-            case BooleanTag | ByteTag | ShortTag | CharTag | IntTag | LongTag | FloatTag | DoubleTag => av.visit(name, const.value)
-            case StringTag =>
-              assert(const.value != null, const) // TODO this invariant isn't documented in `case class Constant`
-              av.visit(name, const.stringValue) // `stringValue` special-cases null, but that execution path isn't exercised for a const with StringTag
-            case ClazzTag => av.visit(name, typeToTypeKind(TypeErasure.erasure(const.typeValue))(bcodeStore)(innerClasesStore).toASMType)
-          }
-        case Ident(nme.WILDCARD) =>
-          // An underscore argument indicates that we want to use the default value for this parameter, so do not emit anything
-        case t: tpd.RefTree if t.symbol.owner.linkedClass.isAllOf(JavaEnum) =>
-          val edesc = innerClasesStore.typeDescriptor(t.tpe) // the class descriptor of the enumeration class.
-          val evalue = t.symbol.javaSimpleName // value the actual enumeration value.
-          av.visitEnum(name, edesc, evalue)
-        case t: SeqLiteral =>
-          val arrAnnotV: AnnotationVisitor = av.visitArray(name)
-          for (arg <- t.elems) { emitArgument(arrAnnotV, null, arg, bcodeStore)(innerClasesStore) }
-          arrAnnotV.visitEnd()
-
-        case Apply(fun, args) if fun.symbol == defn.ArrayClass.primaryConstructor ||
-          toDenot(fun.symbol).owner == defn.ArrayClass.linkedClass && fun.symbol.name == nme.apply =>
-          val arrAnnotV: AnnotationVisitor = av.visitArray(name)
-
-          var actualArgs = if (fun.tpe.isImplicitMethod) {
-            // generic array method, need to get implicit argument out of the way
-            fun.asInstanceOf[Apply].args
-          } else args
-
-          val flatArgs = actualArgs.flatMap { arg =>
-            normalizeArgument(arg) match {
-              case t: tpd.SeqLiteral => t.elems
-              case e => List(e)
-            }
-          }
-          for(arg <- flatArgs) {
-            emitArgument(arrAnnotV, null, arg, bcodeStore)(innerClasesStore)
-          }
-          arrAnnotV.visitEnd()
-  /*
-        case sb @ ScalaSigBytes(bytes) =>
-          // see http://www.scala-lang.org/sid/10 (Storage of pickled Scala signatures in class files)
-          // also JVMS Sec. 4.7.16.1 The element_value structure and JVMS Sec. 4.4.7 The CONSTANT_Utf8_info Structure.
-          if (sb.fitsInOneString) {
-            av.visit(name, BCodeAsmCommon.strEncode(sb))
-          } else {
-            val arrAnnotV: asm.AnnotationVisitor = av.visitArray(name)
-            for(arg <- BCodeAsmCommon.arrEncode(sb)) { arrAnnotV.visit(name, arg) }
-            arrAnnotV.visitEnd()
-          }          // for the lazy val in ScalaSigBytes to be GC'ed, the invoker of emitAnnotations() should hold the ScalaSigBytes in a method-local var that doesn't escape.
-  */
-        case t @ Apply(constr, args) if t.tpe.classSymbol.is(JavaAnnotation) =>
-          val typ = t.tpe.classSymbol.denot.info
-          val assocs = assocsFromApply(t)
-          val desc = innerClasesStore.typeDescriptor(typ) // the class descriptor of the nested annotation class
-          val nestedVisitor = av.visitAnnotation(name, desc)
-          emitAssocs(nestedVisitor, assocs, bcodeStore)(innerClasesStore)
-
-        case t =>
-          report.error(em"Annotation argument is not a constant", t.sourcePos)
-      }
-    }
-
-    private def normalizeArgument(arg: Tree): Tree = arg match {
-      case Trees.NamedArg(_, arg1) => normalizeArgument(arg1)
-      case Trees.Typed(arg1, _) => normalizeArgument(arg1)
-      case _ => arg
-    }
-
-    private def isRuntimeVisible(annot: Annotation): Boolean =
-      if (toDenot(annot.tree.tpe.typeSymbol).hasAnnotation(AnnotationRetentionAttr))
-        retentionPolicyOf(annot) == AnnotationRetentionRuntimeAttr
-      else {
-        // SI-8926: if the annotation class symbol doesn't have a @RetentionPolicy annotation, the
-        // annotation is emitted with visibility `RUNTIME`
-        // dotty bug: #389
-        true
-      }
-
-    private def retentionPolicyOf(annot: Annotation): Symbol =
-      annot.tree.tpe.typeSymbol.getAnnotation(AnnotationRetentionAttr).
-        flatMap(_.argument(0).map(_.tpe.termSymbol)).getOrElse(AnnotationRetentionClassAttr)
-
-    private def assocsFromApply(tree: Tree): List[(Name, Tree)] = {
-      tree match {
-        case Block(_, expr) => assocsFromApply(expr)
-        case Apply(fun, args) =>
-          fun.tpe.widen match {
-            case MethodType(names) =>
-              (names zip args).filter {
-                case (_, t: tpd.Ident) if (t.tpe.normalizedPrefix eq NoPrefix) => false
-                case _ => true
-              }
-          }
-      }
-    }
-  } // end of trait BCAnnotGen
-
-  trait BCJGenSigGen {
-    import int.given
-
-    def getCurrentCUnit(): CompilationUnit
-
-    /**
-     * Generates the generic signature for `sym` before erasure.
-     *
-     * @param sym   The symbol for which to generate a signature.
-     * @param owner The owner of `sym`.
-     * @return The generic signature of `sym` before erasure, as specified in the Java Virtual
-     *         Machine Specification, §4.3.4, or `null` if `sym` doesn't need a generic signature.
-     * @see https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.3.4
-     */
-    def getGenericSignature(sym: Symbol, owner: Symbol): String = {
-      atPhase(erasurePhase) {
-        val memberTpe =
-          if (sym.is(Method)) sym.denot.info
-          else owner.denot.thisType.memberInfo(sym)
-        getGenericSignatureHelper(sym, owner, memberTpe).orNull
-      }
-    }
-
-  } // end of trait BCJGenSigGen
-
-  trait BCForwardersGen extends BCAnnotGen with BCJGenSigGen {
-
-    /* Add a forwarder for method m. Used only from addForwarders().
-     *
-     * must-single-thread
-     */
-    private def addForwarder(jclass: asm.ClassVisitor, module: Symbol, m: Symbol, isSynthetic: Boolean): Unit = {
-      val moduleName     = internalName(module)
-      val methodInfo     = module.thisType.memberInfo(m)
-      val paramJavaTypes: List[BType] = methodInfo.firstParamTypes map toTypeKind
-      // val paramNames     = 0 until paramJavaTypes.length map ("x_" + _)
-
-      /* Forwarders must not be marked final,
-       *  as the JVM will not allow redefinition of a final static method,
-       *  and we don't know what classes might be subclassing the companion class.  See SI-4827.
-       */
-      // TODO: evaluate the other flags we might be dropping on the floor here.
-      val flags = GenBCodeOps.PublicStatic | (
-        if (m.is(JavaVarargs)) asm.Opcodes.ACC_VARARGS else 0
-      ) | (
-        if (isSynthetic) asm.Opcodes.ACC_SYNTHETIC else 0
-      )
-
-      // TODO needed? for(ann <- m.annotations) { ann.symbol.initialize }
-      val jgensig = getStaticForwarderGenericSignature(m, module)
-      val (throws, others) = m.annotations.partition(_.symbol eq defn.ThrowsAnnot)
-      val thrownExceptions: List[String] = getExceptions(throws)
-
-      val jReturnType = toTypeKind(methodInfo.resultType)
-      val mdesc = MethodBType(paramJavaTypes, jReturnType).descriptor
-      val mirrorMethodName = m.javaSimpleName
-      val mirrorMethod: asm.MethodVisitor = jclass.visitMethod(
-        flags,
-        mirrorMethodName,
-        mdesc,
-        jgensig,
-        mkArrayS(thrownExceptions)
-      )
-
-      emitAnnotations(mirrorMethod, others)
-      val params: List[Symbol] = Nil // backend uses this to emit annotations on parameter lists of forwarders
-      // to static methods of companion class
-      // Old assumption: in Dotty this link does not exists: there is no way to get from method type
-      // to inner symbols of DefDef
-      // TODO: now we have paramSymss and could use it here.
-      emitParamAnnotations(mirrorMethod, params.map(_.annotations))
-
-      mirrorMethod.visitCode()
-
-      mirrorMethod.visitFieldInsn(asm.Opcodes.GETSTATIC, moduleName, str.MODULE_INSTANCE_FIELD, symDescriptor(module))
-
-      var index = 0
-      for(jparamType <- paramJavaTypes) {
-        mirrorMethod.visitVarInsn(jparamType.typedOpcode(asm.Opcodes.ILOAD), index)
-        assert(!jparamType.isInstanceOf[MethodBType], jparamType)
-        index += jparamType.size
-      }
-
-      mirrorMethod.visitMethodInsn(asm.Opcodes.INVOKEVIRTUAL, moduleName, mirrorMethodName, asmMethodType(m).descriptor, false)
-      mirrorMethod.visitInsn(jReturnType.typedOpcode(asm.Opcodes.IRETURN))
-
-      mirrorMethod.visitMaxs(0, 0) // just to follow protocol, dummy arguments
-      mirrorMethod.visitEnd()
-
-    }
-
-    /* Add forwarders for all methods defined in `module` that don't conflict
-     *  with methods in the companion class of `module`. A conflict arises when
-     *  a method with the same name is defined both in a class and its companion object:
-     *  method signature is not taken into account.
-     *
-     * must-single-thread
-     */
-    def addForwarders(jclass: asm.ClassVisitor, jclassName: String, moduleClass: Symbol): Unit = {
-      assert(moduleClass.is(ModuleClass), moduleClass)
-      report.debuglog(s"Dumping mirror class for object: $moduleClass")
-
-      val linkedClass  = moduleClass.companionClass
-      lazy val conflictingNames: Set[Name] = {
-        (linkedClass.info.allMembers.collect { case d if d.name.isTermName => d.name }).toSet
-      }
-      report.debuglog(s"Potentially conflicting names for forwarders: $conflictingNames")
-
-      for (m0 <- sortedMembersBasedOnFlags(moduleClass.info, required = Method, excluded = ExcludedForwarder)) {
-        val m = if (m0.is(Bridge)) m0.nextOverriddenSymbol else m0
-        if (m == NoSymbol)
-          report.log(s"$m0 is a bridge method that overrides nothing, something went wrong in a previous phase.")
-        else if (m.isType || m.is(Deferred) || (m.owner eq defn.ObjectClass) || m.isConstructor || m.name.is(ExpandedName))
-          report.debuglog(s"No forwarder for '$m' from $jclassName to '$moduleClass'")
-        else if (conflictingNames(m.name))
-          report.log(s"No forwarder for $m due to conflict with ${linkedClass.info.member(m.name)}")
-        else if (m.accessBoundary(defn.RootClass) ne defn.RootClass)
-          report.log(s"No forwarder for non-public member $m")
-        else {
-          report.log(s"Adding static forwarder for '$m' from $jclassName to '$moduleClass'")
-          // It would be simpler to not generate forwarders for these methods,
-          // but that wouldn't be binary-compatible with Scala 3.0.0, so instead
-          // we generate ACC_SYNTHETIC forwarders so Java compilers ignore them.
-          val isSynthetic =
-            m0.name.is(NameKinds.SyntheticSetterName) ||
-            // Only hide bridges generated at Erasure, mixin forwarders are also
-            // marked as bridge but shouldn't be hidden since they don't have a
-            // non-bridge overload.
-            m0.is(Bridge) && m0.initial.validFor.firstPhaseId == erasurePhase.next.id
-          addForwarder(jclass, moduleClass, m, isSynthetic)
-        }
-      }
-    }
-
-    /** The members of this type that have all of `required` flags but none of `excluded` flags set.
-     *  The members are sorted by name and signature to guarantee a stable ordering.
-     */
-    private def sortedMembersBasedOnFlags(tp: Type, required: Flag, excluded: FlagSet): List[Symbol] = {
-      // The output of `memberNames` is a Set, sort it to guarantee a stable ordering.
-      val names = tp.memberNames(takeAllFilter).toSeq.sorted
-      val buffer = mutable.ListBuffer[Symbol]()
-      names.foreach { name =>
-        buffer ++= tp.memberBasedOnFlags(name, required, excluded)
-          .alternatives.sortBy(_.signature)(Signature.lexicographicOrdering).map(_.symbol)
-      }
-      buffer.toList
-    }
-
-    /*
-     * Quoting from JVMS 4.7.5 The Exceptions Attribute
-     *   "The Exceptions attribute indicates which checked exceptions a method may throw.
-     *    There may be at most one Exceptions attribute in each method_info structure."
-     *
-     * The contents of that attribute are determined by the `String[] exceptions` argument to ASM's ClassVisitor.visitMethod()
-     * This method returns such list of internal names.
-     *
-     * must-single-thread
-     */
-    def getExceptions(excs: List[Annotation]): List[String] = {
-      for (case ThrownException(exc) <- excs.distinct)
-      yield internalName(TypeErasure.erasure(exc).classSymbol)
-    }
-  } // end of trait BCForwardersGen
-
-  trait BCClassGen extends BCInnerClassGen {
-
-    // Used as threshold above which a tableswitch bytecode instruction is preferred over a lookupswitch.
-    // There's a space tradeoff between these multi-branch instructions (details in the JVM spec).
-    // The particular value in use for `MIN_SWITCH_DENSITY` reflects a heuristic.
-    val MIN_SWITCH_DENSITY = 0.7
-
-    /*
-     *  Add public static final field serialVersionUID with value `id`
-     *
-     *  can-multi-thread
-     */
-    def addSerialVUID(id: Long, jclass: asm.ClassVisitor): Unit = {
-      // add static serialVersionUID field if `clasz` annotated with `@SerialVersionUID(uid: Long)`
-      jclass.visitField(
-        GenBCodeOps.PrivateStaticFinal,
-        "serialVersionUID",
-        "J",
-        null, // no java-generic-signature
-        java.lang.Long.valueOf(id)
-      ).visitEnd()
-    }
-  } // end of trait BCClassGen
-
-  /* functionality for building plain and mirror classes */
-  abstract class JCommonBuilder
-    extends BCInnerClassGen
-    with    BCAnnotGen
-    with    BCForwardersGen
-    with    BCPickles { }
-
-  /* builder of mirror classes */
-  class JMirrorBuilder extends JCommonBuilder {
-
-    private var cunit: CompilationUnit = _
-    def getCurrentCUnit(): CompilationUnit = cunit;
-
-    /* Generate a mirror class for a top-level module. A mirror class is a class
-     *  containing only static methods that forward to the corresponding method
-     *  on the MODULE instance of the given Scala object.  It will only be
-     *  generated if there is no companion class: if there is, an attempt will
-     *  instead be made to add the forwarder methods to the companion class.
-     *
-     *  must-single-thread
-     */
-    def genMirrorClass(moduleClass: Symbol, cunit: CompilationUnit): asm.tree.ClassNode = {
-      assert(moduleClass.is(ModuleClass))
-      assert(moduleClass.companionClass == NoSymbol, moduleClass)
-      this.cunit = cunit
-      val bType      = mirrorClassBTypeFromSymbol(moduleClass)
-      val moduleName = internalName(moduleClass) // + "$"
-      val mirrorName = bType.internalName
-
-      val mirrorClass = new asm.tree.ClassNode
-      mirrorClass.visit(
-        classfileVersion,
-        bType.info.flags,
-        mirrorName,
-        null /* no java-generic-signature */,
-        ObjectRef.internalName,
-        EMPTY_STRING_ARRAY
-      )
-
-      if (emitSource) {
-        mirrorClass.visitSource("" + cunit.source.file.name,
-                                null /* SourceDebugExtension */)
-      }
-
-      val ssa = None // getAnnotPickle(mirrorName, if (moduleClass.is(Module)) moduleClass.companionClass else moduleClass.companionModule)
-      mirrorClass.visitAttribute(if (ssa.isDefined) pickleMarkerLocal else pickleMarkerForeign)
-      emitAnnotations(mirrorClass, moduleClass.annotations ++ ssa)
-
-      addForwarders(mirrorClass, mirrorName, moduleClass)
-      mirrorClass.visitEnd()
-
-      moduleClass.name // this side-effect is necessary, really.
-
-      mirrorClass
-    }
-
-  } // end of class JMirrorBuilder
-
-  trait JAndroidBuilder {
-    self: BCInnerClassGen =>
-
-    /* From the reference documentation of the Android SDK:
-     *  The `Parcelable` interface identifies classes whose instances can be written to and restored from a `Parcel`.
-     *  Classes implementing the `Parcelable` interface must also have a static field called `CREATOR`,
-     *  which is an object implementing the `Parcelable.Creator` interface.
-     */
-    val androidFieldName = "CREATOR".toTermName
-
-    lazy val AndroidParcelableInterface : Symbol = NoSymbol // getClassIfDefined("android.os.Parcelable")
-    lazy val AndroidCreatorClass        : Symbol = NoSymbol // getClassIfDefined("android.os.Parcelable$Creator")
-
-    /*
-     * must-single-thread
-     */
-    def isAndroidParcelableClass(sym: Symbol) =
-      (AndroidParcelableInterface != NoSymbol) &&
-      (sym.info.parents.map(_.typeSymbol) contains AndroidParcelableInterface)
-
-    /*
-     * must-single-thread
-     */
-    def legacyAddCreatorCode(clinit: asm.MethodVisitor, cnode: asm.tree.ClassNode, thisName: String): Unit = {
-      val androidCreatorType = getClassBType(AndroidCreatorClass)
-      val tdesc_creator = androidCreatorType.descriptor
-
-      cnode.visitField(
-        GenBCodeOps.PublicStaticFinal,
-        "CREATOR",
-        tdesc_creator,
-        null, // no java-generic-signature
-        null  // no initial value
-      ).visitEnd()
-
-      val moduleName = (thisName + "$")
-
-      // GETSTATIC `moduleName`.MODULE$ : `moduleName`;
-      clinit.visitFieldInsn(
-        asm.Opcodes.GETSTATIC,
-        moduleName,
-        str.MODULE_INSTANCE_FIELD,
-        "L" + moduleName + ";"
-      )
-
-      // INVOKEVIRTUAL `moduleName`.CREATOR() : android.os.Parcelable$Creator;
-      val bt = MethodBType(Nil, androidCreatorType)
-      clinit.visitMethodInsn(
-        asm.Opcodes.INVOKEVIRTUAL,
-        moduleName,
-        "CREATOR",
-        bt.descriptor,
-        false
-      )
-
-      // PUTSTATIC `thisName`.CREATOR;
-      clinit.visitFieldInsn(
-        asm.Opcodes.PUTSTATIC,
-        thisName,
-        "CREATOR",
-        tdesc_creator
-      )
-    }
-
-  } // end of trait JAndroidBuilder
-
-  /**
-   * This method returns the BType for a type reference, for example a parameter type.
-   *
-   * If the result is a ClassBType for a nested class, it is added to the innerClassBufferASM.
-   *
-   * If `t` references a class, toTypeKind ensures that the class is not an implementation class.
-   * See also comment on getClassBTypeAndRegisterInnerClass, which is invoked for implementation
-   * classes.
-   */
-  private def typeToTypeKind(tp: Type)(ct: BCodeHelpers)(storage: ct.BCInnerClassGen): ct.bTypes.BType = {
-    import ct.bTypes._
-    val defn = ctx.definitions
-    import coreBTypes._
-    import Types._
-    /**
-      * Primitive types are represented as TypeRefs to the class symbol of, for example, scala.Int.
-      * The `primitiveTypeMap` maps those class symbols to the corresponding PrimitiveBType.
-      */
-    def primitiveOrClassToBType(sym: Symbol): BType = {
-      assert(sym.isClass, sym)
-      assert(sym != defn.ArrayClass || compilingArray, sym)
-      primitiveTypeMap.getOrElse(sym, storage.getClassBType(sym)).asInstanceOf[BType]
-    }
-
-    /**
-      * When compiling Array.scala, the type parameter T is not erased and shows up in method
-      * signatures, e.g. `def apply(i: Int): T`. A TyperRef to T is replaced by ObjectReference.
-      */
-    def nonClassTypeRefToBType(sym: Symbol): ClassBType = {
-      assert(sym.isType && compilingArray, sym)
-      ObjectRef.asInstanceOf[ct.bTypes.ClassBType]
-    }
-
-    tp.widenDealias match {
-      case JavaArrayType(el) =>ArrayBType(typeToTypeKind(el)(ct)(storage)) // Array type such as Array[Int] (kept by erasure)
-      case t: TypeRef =>
-        t.info match {
-
-          case _ =>
-            if (!t.symbol.isClass) nonClassTypeRefToBType(t.symbol)  // See comment on nonClassTypeRefToBType
-            else primitiveOrClassToBType(t.symbol) // Common reference to a type such as scala.Int or java.lang.String
-        }
-      case Types.ClassInfo(_, sym, _, _, _)           => primitiveOrClassToBType(sym) // We get here, for example, for genLoadModule, which invokes toTypeKind(moduleClassSymbol.info)
-
-      /* AnnotatedType should (probably) be eliminated by erasure. However we know it happens for
-        * meta-annotated annotations (@(ann @getter) val x = 0), so we don't emit a warning.
-        * The type in the AnnotationInfo is an AnnotatedTpe. Tested in jvm/annotations.scala.
-        */
-      case a @ AnnotatedType(t, _) =>
-        report.debuglog(s"typeKind of annotated type $a")
-        typeToTypeKind(t)(ct)(storage)
-
-      /* The cases below should probably never occur. They are kept for now to avoid introducing
-        * new compiler crashes, but we added a warning. The compiler / library bootstrap and the
-        * test suite don't produce any warning.
-        */
-
-      case tp =>
-        report.warning(
-          s"an unexpected type representation reached the compiler backend while compiling ${ctx.compilationUnit}: $tp. " +
-            "If possible, please file a bug on https://github.com/scala/scala3/issues")
-
-        tp match {
-          case tp: ThisType if tp.cls == defn.ArrayClass => ObjectRef.asInstanceOf[ct.bTypes.ClassBType] // was introduced in 9b17332f11 to fix SI-999, but this code is not reached in its test, or any other test
-          case tp: ThisType                         => storage.getClassBType(tp.cls)
-          // case t: SingletonType                   => primitiveOrClassToBType(t.classSymbol)
-          case t: SingletonType                     => typeToTypeKind(t.underlying)(ct)(storage)
-          case t: RefinedType                       => typeToTypeKind(t.parent)(ct)(storage) //parents.map(_.toTypeKind(ct)(storage).asClassBType).reduceLeft((a, b) => a.jvmWiseLUB(b))
-        }
-    }
-  }
-
-  private def getGenericSignatureHelper(sym: Symbol, owner: Symbol, memberTpe: Type)(using Context): Option[String] = {
-    if (needsGenericSignature(sym)) {
-      val erasedTypeSym = TypeErasure.fullErasure(sym.denot.info).typeSymbol
-      if (erasedTypeSym.isPrimitiveValueClass) {
-        // Suppress signatures for symbols whose types erase in the end to primitive
-        // value types. This is needed to fix #7416.
-        None
-      } else {
-        val jsOpt = GenericSignatures.javaSig(sym, memberTpe)
-        if (ctx.settings.XverifySignatures.value) {
-          jsOpt.foreach(verifySignature(sym, _))
-        }
-
-        jsOpt
-      }
-    } else {
-      None
-    }
-  }
-
-  private def verifySignature(sym: Symbol, sig: String)(using Context): Unit = {
-    import scala.tools.asm.util.CheckClassAdapter
-    def wrap(body: => Unit): Unit = {
-      try body
-      catch {
-        case ex: Throwable =>
-          report.error(
-            em"""|compiler bug: created invalid generic signature for $sym in ${sym.denot.owner.showFullName}
-                 |signature: $sig
-                 |if this is reproducible, please report bug at https://github.com/scala/scala3/issues
-               """, sym.sourcePos)
-          throw  ex
-      }
-    }
-
-    wrap {
-      if (sym.is(Method)) {
-        CheckClassAdapter.checkMethodSignature(sig)
-      }
-      else if (sym.isTerm) {
-        CheckClassAdapter.checkFieldSignature(sig)
-      }
-      else {
-        CheckClassAdapter.checkClassSignature(sig)
-      }
-    }
-  }
-
-  // @M don't generate java generics sigs for (members of) implementation
-  // classes, as they are monomorphic (TODO: ok?)
-  private final def needsGenericSignature(sym: Symbol): Boolean = !(
-    // pp: this condition used to include sym.hasexpandedname, but this leads
-    // to the total loss of generic information if a private member is
-    // accessed from a closure: both the field and the accessor were generated
-    // without it.  This is particularly bad because the availability of
-    // generic information could disappear as a consequence of a seemingly
-    // unrelated change.
-      ctx.base.settings.YnoGenericSig.value
-    || sym.is(Artifact)
-    || sym.isAllOf(LiftedMethod)
-    || sym.is(Bridge)
-  )
-
-  private def getStaticForwarderGenericSignature(sym: Symbol, moduleClass: Symbol): String = {
-    // scala/bug#3452 Static forwarder generation uses the same erased signature as the method if forwards to.
-    // By rights, it should use the signature as-seen-from the module class, and add suitable
-    // primitive and value-class boxing/unboxing.
-    // But for now, just like we did in mixin, we just avoid writing a wrong generic signature
-    // (one that doesn't erase to the actual signature). See run/t3452b for a test case.
-
-    val memberTpe = atPhase(erasurePhase) { moduleClass.denot.thisType.memberInfo(sym) }
-    val erasedMemberType = ElimErasedValueType.elimEVT(TypeErasure.transformInfo(sym, memberTpe))
-    if (erasedMemberType =:= sym.denot.info)
-      getGenericSignatureHelper(sym, moduleClass, memberTpe).orNull
-    else null
-  }
-
-  def abort(msg: String): Nothing = {
-    report.error(msg)
-    throw new RuntimeException(msg)
-  }
-
-  private def compilingArray(using Context) =
-    ctx.compilationUnit.source.file.name == "Array.scala"
-}
-
-object BCodeHelpers {
-
-  class InvokeStyle(val style: Int) extends AnyVal {
-    import InvokeStyle._
-    def isVirtual: Boolean = this == Virtual
-    def isStatic : Boolean = this == Static
-    def isSpecial: Boolean = this == Special
-    def isSuper  : Boolean = this == Super
-
-    def hasInstance = this != Static
-  }
-
-  object InvokeStyle {
-    val Virtual = new InvokeStyle(0) // InvokeVirtual or InvokeInterface
-    val Static  = new InvokeStyle(1) // InvokeStatic
-    val Special = new InvokeStyle(2) // InvokeSpecial (private methods, constructors)
-    val Super   = new InvokeStyle(3) // InvokeSpecial (super calls)
-  }
-
-  /** An attachment on Apply nodes indicating that it should be compiled with
-   *  `invokespecial` instead of `invokevirtual`. This is used for static
-   *  forwarders.
-   *  See BCodeSkelBuilder.makeStaticForwarder for more details.
-   */
-  val UseInvokeSpecial = new dotc.util.Property.Key[Unit]
-
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/BCodeIdiomatic.scala b/tests/pos-with-compiler-cc/backend/jvm/BCodeIdiomatic.scala
deleted file mode 100644
index 9b8d81bbdbd1..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/BCodeIdiomatic.scala
+++ /dev/null
@@ -1,727 +0,0 @@
-package dotty.tools
-package backend
-package jvm
-
-import scala.language.unsafeNulls
-
-import scala.tools.asm
-import scala.annotation.switch
-import Primitives.{NE, EQ, TestOp, ArithmeticOp}
-import scala.tools.asm.tree.MethodInsnNode
-import dotty.tools.dotc.report
-
-/*
- *  A high-level facade to the ASM API for bytecode generation.
- *
- *  @author  Miguel Garcia, http://lamp.epfl.ch/~magarcia/ScalaCompilerCornerReloaded
- *  @version 1.0
- *
- */
-trait BCodeIdiomatic extends Pure {
-  val int: DottyBackendInterface
-  final lazy val bTypes = new BTypesFromSymbols[int.type](int)
-
-  import int.{_, given}
-  import bTypes._
-  import coreBTypes._
-
-
-
-  lazy val target =
-    val releaseValue = Option(ctx.settings.javaOutputVersion.value).filter(_.nonEmpty)
-    val targetValue = Option(ctx.settings.XuncheckedJavaOutputVersion.value).filter(_.nonEmpty)
-    val defaultTarget = "8"
-    (releaseValue, targetValue) match
-      case (Some(release), None) => release
-      case (None, Some(target)) => target
-      case (Some(release), Some(_)) =>
-        report.warning(s"The value of ${ctx.settings.XuncheckedJavaOutputVersion.name} was overridden by ${ctx.settings.javaOutputVersion.name}")
-        release
-      case (None, None) => "8" // least supported version by default
-
-
-  // Keep synchronized with `minTargetVersion` and `maxTargetVersion` in ScalaSettings
-  lazy val classfileVersion: Int = target match {
-    case "8"  => asm.Opcodes.V1_8
-    case "9"  => asm.Opcodes.V9
-    case "10" => asm.Opcodes.V10
-    case "11" => asm.Opcodes.V11
-    case "12" => asm.Opcodes.V12
-    case "13" => asm.Opcodes.V13
-    case "14" => asm.Opcodes.V14
-    case "15" => asm.Opcodes.V15/*
-    case "16" => asm.Opcodes.V16
-    case "17" => asm.Opcodes.V17
-    case "18" => asm.Opcodes.V18
-    case "19" => asm.Opcodes.V19
-    case "20" => asm.Opcodes.V20
-    case "21" => asm.Opcodes.V21
-    case "22" => asm.Opcodes.V22*/
-  }
-
-  lazy val majorVersion: Int = (classfileVersion & 0xFF)
-  lazy val emitStackMapFrame = (majorVersion >= 50)
-
-  val extraProc: Int =
-    import GenBCodeOps.addFlagIf
-    asm.ClassWriter.COMPUTE_MAXS
-      .addFlagIf(emitStackMapFrame, asm.ClassWriter.COMPUTE_FRAMES)
-
-  lazy val JavaStringBuilderClassName = jlStringBuilderRef.internalName
-
-  val CLASS_CONSTRUCTOR_NAME    = "<clinit>"
-  val INSTANCE_CONSTRUCTOR_NAME = "<init>"
-
-  val EMPTY_STRING_ARRAY   = Array.empty[String]
-  val EMPTY_INT_ARRAY      = Array.empty[Int]
-  val EMPTY_LABEL_ARRAY    = Array.empty[asm.Label]
-  val EMPTY_BTYPE_ARRAY    = Array.empty[BType]
-
-  /* can-multi-thread */
-  final def mkArrayB(xs: List[BType]): Array[BType] = {
-    if (xs.isEmpty) { return EMPTY_BTYPE_ARRAY }
-    val a = new Array[BType](xs.size); xs.copyToArray(a); a
-  }
-  /* can-multi-thread */
-  final def mkArrayS(xs: List[String]): Array[String] = {
-    if (xs.isEmpty) { return EMPTY_STRING_ARRAY }
-    val a = new Array[String](xs.size); xs.copyToArray(a); a
-  }
-  /* can-multi-thread */
-  final def mkArrayL(xs: List[asm.Label]): Array[asm.Label] = {
-    if (xs.isEmpty) { return EMPTY_LABEL_ARRAY }
-    val a = new Array[asm.Label](xs.size); xs.copyToArray(a); a
-  }
-
-  /*
-   * can-multi-thread
-   */
-  final def mkArrayReverse(xs: List[String]): Array[String] = {
-    val len = xs.size
-    if (len == 0) { return EMPTY_STRING_ARRAY }
-    val a = new Array[String](len)
-    var i = len - 1
-    var rest = xs
-    while (!rest.isEmpty) {
-      a(i) = rest.head
-      rest = rest.tail
-      i -= 1
-    }
-    a
-  }
-
-  /*
-   * can-multi-thread
-   */
-  final def mkArrayReverse(xs: List[Int]): Array[Int] = {
-    val len = xs.size
-    if (len == 0) { return EMPTY_INT_ARRAY }
-    val a = new Array[Int](len)
-    var i = len - 1
-    var rest = xs
-    while (!rest.isEmpty) {
-      a(i) = rest.head
-      rest = rest.tail
-      i -= 1
-    }
-    a
-  }
-
-  /* Just a namespace for utilities that encapsulate MethodVisitor idioms.
-   *  In the ASM world, org.objectweb.asm.commons.InstructionAdapter plays a similar role,
-   *  but the methods here allow choosing when to transition from ICode to ASM types
-   *  (including not at all, e.g. for performance).
-   */
-  abstract class JCodeMethodN {
-
-    def jmethod: asm.tree.MethodNode
-
-    import asm.Opcodes;
-
-    final def emit(opc: Int): Unit = { jmethod.visitInsn(opc) }
-
-    /*
-     * can-multi-thread
-     */
-    final def genPrimitiveArithmetic(op: ArithmeticOp, kind: BType): Unit = {
-
-      import Primitives.{ ADD, SUB, MUL, DIV, REM, NOT }
-
-      op match {
-
-        case ADD => add(kind)
-        case SUB => sub(kind)
-        case MUL => mul(kind)
-        case DIV => div(kind)
-        case REM => rem(kind)
-
-        case NOT =>
-          if (kind.isIntSizedType) {
-            emit(Opcodes.ICONST_M1)
-            emit(Opcodes.IXOR)
-          } else if (kind == LONG) {
-            jmethod.visitLdcInsn(java.lang.Long.valueOf(-1))
-            jmethod.visitInsn(Opcodes.LXOR)
-          } else {
-            abort(s"Impossible to negate an $kind")
-          }
-
-        case _ =>
-          abort(s"Unknown arithmetic primitive $op")
-      }
-
-    } // end of method genPrimitiveArithmetic()
-
-    /*
-     * can-multi-thread
-     */
-    final def genPrimitiveLogical(op: /* LogicalOp */ Int, kind: BType): Unit = {
-
-      import ScalaPrimitivesOps.{ AND, OR, XOR }
-
-      ((op, kind): @unchecked) match {
-        case (AND, LONG) => emit(Opcodes.LAND)
-        case (AND, INT)  => emit(Opcodes.IAND)
-        case (AND, _)    =>
-          emit(Opcodes.IAND)
-          if (kind != BOOL) { emitT2T(INT, kind) }
-
-        case (OR, LONG) => emit(Opcodes.LOR)
-        case (OR, INT)  => emit(Opcodes.IOR)
-        case (OR, _) =>
-          emit(Opcodes.IOR)
-          if (kind != BOOL) { emitT2T(INT, kind) }
-
-        case (XOR, LONG) => emit(Opcodes.LXOR)
-        case (XOR, INT)  => emit(Opcodes.IXOR)
-        case (XOR, _) =>
-          emit(Opcodes.IXOR)
-          if (kind != BOOL) { emitT2T(INT, kind) }
-      }
-
-    } // end of method genPrimitiveLogical()
-
-    /*
-     * can-multi-thread
-     */
-    final def genPrimitiveShift(op: /* ShiftOp */ Int, kind: BType): Unit = {
-
-      import ScalaPrimitivesOps.{ LSL, ASR, LSR }
-
-      ((op, kind): @unchecked) match {
-        case (LSL, LONG) => emit(Opcodes.LSHL)
-        case (LSL, INT)  => emit(Opcodes.ISHL)
-        case (LSL, _) =>
-          emit(Opcodes.ISHL)
-          emitT2T(INT, kind)
-
-        case (ASR, LONG) => emit(Opcodes.LSHR)
-        case (ASR, INT)  => emit(Opcodes.ISHR)
-        case (ASR, _) =>
-          emit(Opcodes.ISHR)
-          emitT2T(INT, kind)
-
-        case (LSR, LONG) => emit(Opcodes.LUSHR)
-        case (LSR, INT)  => emit(Opcodes.IUSHR)
-        case (LSR, _) =>
-          emit(Opcodes.IUSHR)
-          emitT2T(INT, kind)
-      }
-
-    } // end of method genPrimitiveShift()
-
-    /* Creates a new `StringBuilder` instance with the requested capacity
-     *
-     * can-multi-thread
-     */
-    final def genNewStringBuilder(size: Int): Unit = {
-      jmethod.visitTypeInsn(Opcodes.NEW, JavaStringBuilderClassName)
-      jmethod.visitInsn(Opcodes.DUP)
-      jmethod.visitLdcInsn(Integer.valueOf(size))
-      invokespecial(
-        JavaStringBuilderClassName,
-        INSTANCE_CONSTRUCTOR_NAME,
-        "(I)V",
-        itf = false
-      )
-    }
-
-    /* Issue a call to `StringBuilder#append` for the right element type
-     *
-     * can-multi-thread
-     */
-    final def genStringBuilderAppend(elemType: BType): Unit = {
-      val paramType = elemType match {
-        case ct: ClassBType if ct.isSubtypeOf(StringRef)          => StringRef
-        case ct: ClassBType if ct.isSubtypeOf(jlStringBufferRef)  => jlStringBufferRef
-        case ct: ClassBType if ct.isSubtypeOf(jlCharSequenceRef)  => jlCharSequenceRef
-        // Don't match for `ArrayBType(CHAR)`, even though StringBuilder has such an overload:
-        // `"a" + Array('b')` should NOT be "ab", but "a[C@...".
-        case _: RefBType                                              => ObjectRef
-        // jlStringBuilder does not have overloads for byte and short, but we can just use the int version
-        case BYTE | SHORT                                             => INT
-        case pt: PrimitiveBType                                       => pt
-      }
-      val bt = MethodBType(List(paramType), jlStringBuilderRef)
-      invokevirtual(JavaStringBuilderClassName, "append", bt.descriptor)
-    }
-
-    /* Extract the built `String` from the `StringBuilder`
-     *
-     * can-multi-thread
-     */
-    final def genStringBuilderEnd: Unit = {
-      invokevirtual(JavaStringBuilderClassName, "toString", genStringBuilderEndDesc)
-    }
-    // Use ClassBType refs instead of plain string literal to make sure that needed ClassBTypes are initialized and reachable
-    private lazy val genStringBuilderEndDesc = MethodBType(Nil, StringRef).descriptor
-
-    /* Concatenate top N arguments on the stack with `StringConcatFactory#makeConcatWithConstants`
-     * (only works for JDK 9+)
-     *
-     * can-multi-thread
-     */
-    final def genIndyStringConcat(
-      recipe: String,
-      argTypes: Seq[asm.Type],
-      constants: Seq[String]
-    ): Unit = {
-      jmethod.visitInvokeDynamicInsn(
-        "makeConcatWithConstants",
-        asm.Type.getMethodDescriptor(StringRef.toASMType, argTypes:_*),
-        coreBTypes.jliStringConcatFactoryMakeConcatWithConstantsHandle,
-        (recipe +: constants):_*
-      )
-    }
-
-    /*
-     * Emits one or more conversion instructions based on the types given as arguments.
-     *
-     * @param from The type of the value to be converted into another type.
-     * @param to   The type the value will be converted into.
-     *
-     * can-multi-thread
-     */
-    final def emitT2T(from: BType, to: BType): Unit = {
-
-      assert(
-        from.isNonVoidPrimitiveType && to.isNonVoidPrimitiveType,
-        s"Cannot emit primitive conversion from $from to $to"
-      )
-
-          def pickOne(opcs: Array[Int]): Unit = { // TODO index on to.sort
-            val chosen = (to: @unchecked) match {
-              case BYTE   => opcs(0)
-              case SHORT  => opcs(1)
-              case CHAR   => opcs(2)
-              case INT    => opcs(3)
-              case LONG   => opcs(4)
-              case FLOAT  => opcs(5)
-              case DOUBLE => opcs(6)
-            }
-            if (chosen != -1) { emit(chosen) }
-          }
-
-      if (from == to) { return }
-      // the only conversion involving BOOL that is allowed is (BOOL -> BOOL)
-      assert(from != BOOL && to != BOOL, s"inconvertible types : $from -> $to")
-
-      // We're done with BOOL already
-      from match {
-
-        // using `asm.Type.SHORT` instead of `BType.SHORT` because otherwise "warning: could not emit switch for @switch annotated match"
-
-        case BYTE  => pickOne(JCodeMethodN.fromByteT2T)
-        case SHORT => pickOne(JCodeMethodN.fromShortT2T)
-        case CHAR  => pickOne(JCodeMethodN.fromCharT2T)
-        case INT   => pickOne(JCodeMethodN.fromIntT2T)
-
-        case FLOAT  =>
-          import asm.Opcodes.{ F2L, F2D, F2I }
-          to match {
-            case LONG    => emit(F2L)
-            case DOUBLE  => emit(F2D)
-            case _       => emit(F2I); emitT2T(INT, to)
-          }
-
-        case LONG   =>
-          import asm.Opcodes.{ L2F, L2D, L2I }
-          to match {
-            case FLOAT   => emit(L2F)
-            case DOUBLE  => emit(L2D)
-            case _       => emit(L2I); emitT2T(INT, to)
-          }
-
-        case DOUBLE =>
-          import asm.Opcodes.{ D2L, D2F, D2I }
-          to match {
-            case FLOAT   => emit(D2F)
-            case LONG    => emit(D2L)
-            case _       => emit(D2I); emitT2T(INT, to)
-          }
-      }
-    } // end of emitT2T()
-
-    // can-multi-thread
-    final def boolconst(b: Boolean): Unit = { iconst(if (b) 1 else 0) }
-
-    // can-multi-thread
-    final def iconst(cst: Int): Unit = {
-      if (cst >= -1 && cst <= 5) {
-        emit(Opcodes.ICONST_0 + cst)
-      } else if (cst >= java.lang.Byte.MIN_VALUE && cst <= java.lang.Byte.MAX_VALUE) {
-        jmethod.visitIntInsn(Opcodes.BIPUSH, cst)
-      } else if (cst >= java.lang.Short.MIN_VALUE && cst <= java.lang.Short.MAX_VALUE) {
-        jmethod.visitIntInsn(Opcodes.SIPUSH, cst)
-      } else {
-        jmethod.visitLdcInsn(Integer.valueOf(cst))
-      }
-    }
-
-    // can-multi-thread
-    final def lconst(cst: Long): Unit = {
-      if (cst == 0L || cst == 1L) {
-        emit(Opcodes.LCONST_0 + cst.asInstanceOf[Int])
-      } else {
-        jmethod.visitLdcInsn(java.lang.Long.valueOf(cst))
-      }
-    }
-
-    // can-multi-thread
-    final def fconst(cst: Float): Unit = {
-      val bits: Int = java.lang.Float.floatToIntBits(cst)
-      if (bits == 0L || bits == 0x3f800000 || bits == 0x40000000) { // 0..2
-        emit(Opcodes.FCONST_0 + cst.asInstanceOf[Int])
-      } else {
-        jmethod.visitLdcInsn(java.lang.Float.valueOf(cst))
-      }
-    }
-
-    // can-multi-thread
-    final def dconst(cst: Double): Unit = {
-      val bits: Long = java.lang.Double.doubleToLongBits(cst)
-      if (bits == 0L || bits == 0x3ff0000000000000L) { // +0.0d and 1.0d
-        emit(Opcodes.DCONST_0 + cst.asInstanceOf[Int])
-      } else {
-        jmethod.visitLdcInsn(java.lang.Double.valueOf(cst))
-      }
-    }
-
-    // can-multi-thread
-    final def newarray(elem: BType): Unit = {
-      elem match {
-        case c: RefBType =>
-          /* phantom type at play in `Array(null)`, SI-1513. On the other hand, Array(()) has element type `scala.runtime.BoxedUnit` which isObject. */
-          jmethod.visitTypeInsn(Opcodes.ANEWARRAY, c.classOrArrayType)
-        case _ =>
-          assert(elem.isNonVoidPrimitiveType)
-          val rand = {
-            // using `asm.Type.SHORT` instead of `BType.SHORT` because otherwise "warning: could not emit switch for @switch annotated match"
-            elem match {
-              case BOOL   => Opcodes.T_BOOLEAN
-              case BYTE   => Opcodes.T_BYTE
-              case SHORT  => Opcodes.T_SHORT
-              case CHAR   => Opcodes.T_CHAR
-              case INT    => Opcodes.T_INT
-              case LONG   => Opcodes.T_LONG
-              case FLOAT  => Opcodes.T_FLOAT
-              case DOUBLE => Opcodes.T_DOUBLE
-            }
-          }
-          jmethod.visitIntInsn(Opcodes.NEWARRAY, rand)
-      }
-    }
-
-
-    final def load( idx: Int, tk: BType): Unit = { emitVarInsn(Opcodes.ILOAD,  idx, tk) } // can-multi-thread
-    final def store(idx: Int, tk: BType): Unit = { emitVarInsn(Opcodes.ISTORE, idx, tk) } // can-multi-thread
-    final def iinc( idx: Int, increment: Int): Unit = jmethod.visitIincInsn(idx, increment) // can-multi-thread
-
-    final def aload( tk: BType): Unit = { emitTypeBased(JCodeMethodN.aloadOpcodes,  tk) } // can-multi-thread
-    final def astore(tk: BType): Unit = { emitTypeBased(JCodeMethodN.astoreOpcodes, tk) } // can-multi-thread
-
-    final def neg(tk: BType): Unit = { emitPrimitive(JCodeMethodN.negOpcodes, tk) } // can-multi-thread
-    final def add(tk: BType): Unit = { emitPrimitive(JCodeMethodN.addOpcodes, tk) } // can-multi-thread
-    final def sub(tk: BType): Unit = { emitPrimitive(JCodeMethodN.subOpcodes, tk) } // can-multi-thread
-    final def mul(tk: BType): Unit = { emitPrimitive(JCodeMethodN.mulOpcodes, tk) } // can-multi-thread
-    final def div(tk: BType): Unit = { emitPrimitive(JCodeMethodN.divOpcodes, tk) } // can-multi-thread
-    final def rem(tk: BType): Unit = { emitPrimitive(JCodeMethodN.remOpcodes, tk) } // can-multi-thread
-
-    // can-multi-thread
-    final def invokespecial(owner: String, name: String, desc: String, itf: Boolean): Unit = {
-      emitInvoke(Opcodes.INVOKESPECIAL, owner, name, desc, itf)
-    }
-    // can-multi-thread
-    final def invokestatic(owner: String, name: String, desc: String, itf: Boolean): Unit = {
-      emitInvoke(Opcodes.INVOKESTATIC, owner, name, desc, itf)
-    }
-    // can-multi-thread
-    final def invokeinterface(owner: String, name: String, desc: String): Unit = {
-      emitInvoke(Opcodes.INVOKEINTERFACE, owner, name, desc, itf = true)
-    }
-    // can-multi-thread
-    final def invokevirtual(owner: String, name: String, desc: String): Unit = {
-      emitInvoke(Opcodes.INVOKEVIRTUAL, owner, name, desc, itf = false)
-    }
-
-    def emitInvoke(opcode: Int, owner: String, name: String, desc: String, itf: Boolean): Unit = {
-      val node = new MethodInsnNode(opcode, owner, name, desc, itf)
-      jmethod.instructions.add(node)
-    }
-
-
-    // can-multi-thread
-    final def goTo(label: asm.Label): Unit = { jmethod.visitJumpInsn(Opcodes.GOTO, label) }
-    // can-multi-thread
-    final def emitIF(cond: TestOp, label: asm.Label): Unit =      { jmethod.visitJumpInsn(cond.opcodeIF(),     label) }
-    // can-multi-thread
-    final def emitIF_ICMP(cond: TestOp, label: asm.Label): Unit = { jmethod.visitJumpInsn(cond.opcodeIFICMP(), label) }
-    // can-multi-thread
-    final def emitIF_ACMP(cond: TestOp, label: asm.Label): Unit = {
-      assert((cond == EQ) || (cond == NE), cond)
-      val opc = (if (cond == EQ) Opcodes.IF_ACMPEQ else Opcodes.IF_ACMPNE)
-      jmethod.visitJumpInsn(opc, label)
-    }
-    // can-multi-thread
-    final def emitIFNONNULL(label: asm.Label): Unit = { jmethod.visitJumpInsn(Opcodes.IFNONNULL, label) }
-    // can-multi-thread
-    final def emitIFNULL   (label: asm.Label): Unit = { jmethod.visitJumpInsn(Opcodes.IFNULL,    label) }
-
-    // can-multi-thread
-    final def emitRETURN(tk: BType): Unit = {
-      if (tk == UNIT) { emit(Opcodes.RETURN) }
-      else            { emitTypeBased(JCodeMethodN.returnOpcodes, tk)      }
-    }
-
-    /* Emits one of tableswitch or lookoupswitch.
-     *
-     * can-multi-thread
-     */
-    final def emitSWITCH(keys: Array[Int], branches: Array[asm.Label], defaultBranch: asm.Label, minDensity: Double): Unit = {
-      assert(keys.length == branches.length)
-
-      // For empty keys, it makes sense emitting LOOKUPSWITCH with defaultBranch only.
-      // Similar to what javac emits for a switch statement consisting only of a default case.
-      if (keys.length == 0) {
-        jmethod.visitLookupSwitchInsn(defaultBranch, keys, branches)
-        return
-      }
-
-      // sort `keys` by increasing key, keeping `branches` in sync. TODO FIXME use quicksort
-      var i = 1
-      while (i < keys.length) {
-        var j = 1
-        while (j <= keys.length - i) {
-          if (keys(j) < keys(j - 1)) {
-            val tmp     = keys(j)
-            keys(j)     = keys(j - 1)
-            keys(j - 1) = tmp
-            val tmpL        = branches(j)
-            branches(j)     = branches(j - 1)
-            branches(j - 1) = tmpL
-          }
-          j += 1
-        }
-        i += 1
-      }
-
-      // check for duplicate keys to avoid "VerifyError: unsorted lookupswitch" (SI-6011)
-      i = 1
-      while (i < keys.length) {
-        if (keys(i-1) == keys(i)) {
-          abort("duplicate keys in SWITCH, can't pick arbitrarily one of them to evict, see SI-6011.")
-        }
-        i += 1
-      }
-
-      val keyMin = keys(0)
-      val keyMax = keys(keys.length - 1)
-
-      val isDenseEnough: Boolean = {
-        /* Calculate in long to guard against overflow. TODO what overflow? */
-        val keyRangeD: Double = (keyMax.asInstanceOf[Long] - keyMin + 1).asInstanceOf[Double]
-        val klenD:     Double = keys.length
-        val kdensity:  Double = (klenD / keyRangeD)
-
-        kdensity >= minDensity
-      }
-
-      if (isDenseEnough) {
-        // use a table in which holes are filled with defaultBranch.
-        val keyRange    = (keyMax - keyMin + 1)
-        val newBranches = new Array[asm.Label](keyRange)
-        var oldPos = 0
-        var i = 0
-        while (i < keyRange) {
-          val key = keyMin + i;
-          if (keys(oldPos) == key) {
-            newBranches(i) = branches(oldPos)
-            oldPos += 1
-          } else {
-            newBranches(i) = defaultBranch
-          }
-          i += 1
-        }
-        assert(oldPos == keys.length, "emitSWITCH")
-        jmethod.visitTableSwitchInsn(keyMin, keyMax, defaultBranch, newBranches: _*)
-      } else {
-        jmethod.visitLookupSwitchInsn(defaultBranch, keys, branches)
-      }
-    }
-
-    // internal helpers -- not part of the public API of `jcode`
-    // don't make private otherwise inlining will suffer
-
-    // can-multi-thread
-    final def emitVarInsn(opc: Int, idx: Int, tk: BType): Unit = {
-      assert((opc == Opcodes.ILOAD) || (opc == Opcodes.ISTORE), opc)
-      jmethod.visitVarInsn(tk.typedOpcode(opc), idx)
-    }
-
-    // ---------------- array load and store ----------------
-
-    // can-multi-thread
-    final def emitTypeBased(opcs: Array[Int], tk: BType): Unit = {
-      assert(tk != UNIT, tk)
-      val opc = {
-        if (tk.isRef) { opcs(0) }
-        else if (tk.isIntSizedType) {
-          (tk: @unchecked) match {
-            case BOOL | BYTE     => opcs(1)
-            case SHORT           => opcs(2)
-            case CHAR            => opcs(3)
-            case INT             => opcs(4)
-          }
-        } else {
-          (tk: @unchecked) match {
-            case LONG            => opcs(5)
-            case FLOAT           => opcs(6)
-            case DOUBLE          => opcs(7)
-          }
-        }
-      }
-      emit(opc)
-    }
-
-    // ---------------- primitive operations ----------------
-
-     // can-multi-thread
-    final def emitPrimitive(opcs: Array[Int], tk: BType): Unit = {
-      val opc = {
-        // using `asm.Type.SHORT` instead of `BType.SHORT` because otherwise "warning: could not emit switch for @switch annotated match"
-        tk match {
-          case LONG   => opcs(1)
-          case FLOAT  => opcs(2)
-          case DOUBLE => opcs(3)
-          case _      => opcs(0)
-        }
-      }
-      emit(opc)
-    }
-
-    // can-multi-thread
-    final def drop(tk: BType): Unit = { emit(if (tk.isWideType) Opcodes.POP2 else Opcodes.POP) }
-
-    // can-multi-thread
-    final def dup(tk: BType): Unit =  { emit(if (tk.isWideType) Opcodes.DUP2 else Opcodes.DUP) }
-
-    // ---------------- type checks and casts ----------------
-
-    // can-multi-thread
-    final def isInstance(tk: RefBType): Unit = {
-      jmethod.visitTypeInsn(Opcodes.INSTANCEOF, tk.classOrArrayType)
-    }
-
-    // can-multi-thread
-    final def checkCast(tk: RefBType): Unit = {
-      // TODO ICode also requires: but that's too much, right? assert(!isBoxedType(tk),     "checkcast on boxed type: " + tk)
-      jmethod.visitTypeInsn(Opcodes.CHECKCAST, tk.classOrArrayType)
-    }
-
-    def abort(msg: String): Nothing = {
-      report.error(msg)
-      throw new RuntimeException(msg)
-    }
-
-  } // end of class JCodeMethodN
-
-  /* Constant-valued val-members of JCodeMethodN at the companion object, so as to avoid re-initializing them multiple times. */
-  object JCodeMethodN {
-
-    import asm.Opcodes._
-
-    // ---------------- conversions ----------------
-
-    val fromByteT2T  = { Array( -1,  -1, I2C,  -1, I2L, I2F, I2D) } // do nothing for (BYTE -> SHORT) and for (BYTE -> INT)
-    val fromCharT2T  = { Array(I2B, I2S,  -1,  -1, I2L, I2F, I2D) } // for (CHAR  -> INT) do nothing
-    val fromShortT2T = { Array(I2B,  -1, I2C,  -1, I2L, I2F, I2D) } // for (SHORT -> INT) do nothing
-    val fromIntT2T   = { Array(I2B, I2S, I2C,  -1, I2L, I2F, I2D) }
-
-    // ---------------- array load and store ----------------
-
-    val aloadOpcodes  = { Array(AALOAD,  BALOAD,  SALOAD,  CALOAD,  IALOAD,  LALOAD,  FALOAD,  DALOAD)  }
-    val astoreOpcodes = { Array(AASTORE, BASTORE, SASTORE, CASTORE, IASTORE, LASTORE, FASTORE, DASTORE) }
-    val returnOpcodes = { Array(ARETURN, IRETURN, IRETURN, IRETURN, IRETURN, LRETURN, FRETURN, DRETURN) }
-
-    // ---------------- primitive operations ----------------
-
-    val negOpcodes: Array[Int] = { Array(INEG, LNEG, FNEG, DNEG) }
-    val addOpcodes: Array[Int] = { Array(IADD, LADD, FADD, DADD) }
-    val subOpcodes: Array[Int] = { Array(ISUB, LSUB, FSUB, DSUB) }
-    val mulOpcodes: Array[Int] = { Array(IMUL, LMUL, FMUL, DMUL) }
-    val divOpcodes: Array[Int] = { Array(IDIV, LDIV, FDIV, DDIV) }
-    val remOpcodes: Array[Int] = { Array(IREM, LREM, FREM, DREM) }
-
-  } // end of object JCodeMethodN
-
-  // ---------------- adapted from scalaPrimitives ----------------
-
-  /* Given `code` reports the src TypeKind of the coercion indicated by `code`.
-   * To find the dst TypeKind, `ScalaPrimitivesOps.generatedKind(code)` can be used.
-   *
-   * can-multi-thread
-   */
-  final def coercionFrom(code: Int): BType = {
-    import ScalaPrimitivesOps._
-    (code: @switch) match {
-      case B2B | B2C | B2S | B2I | B2L | B2F | B2D => BYTE
-      case S2B | S2S | S2C | S2I | S2L | S2F | S2D => SHORT
-      case C2B | C2S | C2C | C2I | C2L | C2F | C2D => CHAR
-      case I2B | I2S | I2C | I2I | I2L | I2F | I2D => INT
-      case L2B | L2S | L2C | L2I | L2L | L2F | L2D => LONG
-      case F2B | F2S | F2C | F2I | F2L | F2F | F2D => FLOAT
-      case D2B | D2S | D2C | D2I | D2L | D2F | D2D => DOUBLE
-    }
-  }
-
-  /* If code is a coercion primitive, the result type.
-   *
-   * can-multi-thread
-   */
-  final def coercionTo(code: Int): BType = {
-    import ScalaPrimitivesOps._
-    (code: @switch) match {
-      case B2B | C2B | S2B | I2B | L2B | F2B | D2B => BYTE
-      case B2C | C2C | S2C | I2C | L2C | F2C | D2C => CHAR
-      case B2S | C2S | S2S | I2S | L2S | F2S | D2S => SHORT
-      case B2I | C2I | S2I | I2I | L2I | F2I | D2I => INT
-      case B2L | C2L | S2L | I2L | L2L | F2L | D2L => LONG
-      case B2F | C2F | S2F | I2F | L2F | F2F | D2F => FLOAT
-      case B2D | C2D | S2D | I2D | L2D | F2D | D2D => DOUBLE
-    }
-  }
-
-  implicit class InsnIterMethodNode(mnode: asm.tree.MethodNode) {
-    @`inline` final def foreachInsn(f: (asm.tree.AbstractInsnNode) => Unit): Unit = { mnode.instructions.foreachInsn(f) }
-  }
-
-  implicit class InsnIterInsnList(lst: asm.tree.InsnList) {
-
-    @`inline` final def foreachInsn(f: (asm.tree.AbstractInsnNode) => Unit): Unit = {
-      val insnIter = lst.iterator()
-      while (insnIter.hasNext) {
-        f(insnIter.next())
-      }
-    }
-  }
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/BCodeSkelBuilder.scala b/tests/pos-with-compiler-cc/backend/jvm/BCodeSkelBuilder.scala
deleted file mode 100644
index 125ee26b0528..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/BCodeSkelBuilder.scala
+++ /dev/null
@@ -1,908 +0,0 @@
-package dotty.tools
-package backend
-package jvm
-
-import scala.language.unsafeNulls
-
-import scala.annotation.tailrec
-
-import scala.collection.{ mutable, immutable }
-
-import scala.tools.asm
-import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.ast.TreeTypeMap
-import dotty.tools.dotc.CompilationUnit
-import dotty.tools.dotc.core.Decorators._
-import dotty.tools.dotc.core.Flags._
-import dotty.tools.dotc.core.StdNames._
-import dotty.tools.dotc.core.NameKinds._
-import dotty.tools.dotc.core.Names.TermName
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.core.Types._
-import dotty.tools.dotc.core.Contexts._
-import dotty.tools.dotc.util.Spans._
-import dotty.tools.dotc.report
-import dotty.tools.dotc.transform.SymUtils._
-
-/*
- *
- *  @author  Miguel Garcia, http://lamp.epfl.ch/~magarcia/ScalaCompilerCornerReloaded/
- *  @version 1.0
- *
- */
-trait BCodeSkelBuilder extends BCodeHelpers {
-  import int.{_, given}
-  import DottyBackendInterface.{symExtensions, _}
-  import tpd._
-  import bTypes._
-  import coreBTypes._
-  import bCodeAsmCommon._
-
-  lazy val NativeAttr: Symbol = requiredClass[scala.native]
-
-  /** The destination of a value generated by `genLoadTo`. */
-  enum LoadDestination:
-    /** The value is put on the stack, and control flows through to the next opcode. */
-    case FallThrough
-    /** The value is put on the stack, and control flow is transferred to the given `label`. */
-    case Jump(label: asm.Label)
-    /** The value is RETURN'ed from the enclosing method. */
-    case Return
-    /** The value is ATHROW'n. */
-    case Throw
-  end LoadDestination
-
-  /*
-   * There's a dedicated PlainClassBuilder for each CompilationUnit,
-   * which simplifies the initialization of per-class data structures in `genPlainClass()` which in turn delegates to `initJClass()`
-   *
-   * The entry-point to emitting bytecode instructions is `genDefDef()` where the per-method data structures are initialized,
-   * including `resetMethodBookkeeping()` and `initJMethod()`.
-   * Once that's been done, and assuming the method being visited isn't abstract, `emitNormalMethodBody()` populates
-   * the ASM MethodNode instance with ASM AbstractInsnNodes.
-   *
-   * Given that CleanUp delivers trees that produce values on the stack,
-   * the entry-point to all-things instruction-emit is `genLoad()`.
-   * There, an operation taking N arguments results in recursively emitting instructions to lead each of them,
-   * followed by emitting instructions to process those arguments (to be found at run-time on the operand-stack).
-   *
-   * In a few cases the above recipe deserves more details, as provided in the documentation for:
-   *   - `genLoadTry()`
-   *   - `genSynchronized()
-   *   - `jumpDest` , `cleanups` , `labelDefsAtOrUnder`
-   */
-  abstract class PlainSkelBuilder(cunit: CompilationUnit)
-    extends BCClassGen
-    with    BCAnnotGen
-    with    BCInnerClassGen
-    with    JAndroidBuilder
-    with    BCForwardersGen
-    with    BCPickles
-    with    BCJGenSigGen {
-
-    // Strangely I can't find this in the asm code 255, but reserving 1 for "this"
-    inline val MaximumJvmParameters = 254
-
-    // current class
-    var cnode: ClassNode1          = null
-    var thisName: String           = null // the internal name of the class being emitted
-
-    var claszSymbol: Symbol        = null
-    var isCZParcelable             = false
-    var isCZStaticModule           = false
-
-    /* ---------------- idiomatic way to ask questions to typer ---------------- */
-
-    def paramTKs(app: Apply, take: Int = -1): List[BType] = app match {
-      case Apply(fun, _) =>
-      val funSym = fun.symbol
-      (funSym.info.firstParamTypes map toTypeKind) // this tracks mentioned inner classes (in innerClassBufferASM)
-    }
-
-    def symInfoTK(sym: Symbol): BType = {
-      toTypeKind(sym.info) // this tracks mentioned inner classes (in innerClassBufferASM)
-    }
-
-    def tpeTK(tree: Tree): BType = { toTypeKind(tree.tpe) }
-
-    override def getCurrentCUnit(): CompilationUnit = { cunit }
-
-    /* ---------------- helper utils for generating classes and fields ---------------- */
-
-    def genPlainClass(cd0: TypeDef) = cd0 match {
-      case TypeDef(_, impl: Template) =>
-      assert(cnode == null, "GenBCode detected nested methods.")
-
-      claszSymbol       = cd0.symbol
-      isCZParcelable    = isAndroidParcelableClass(claszSymbol)
-      isCZStaticModule  = claszSymbol.isStaticModuleClass
-      thisName          = internalName(claszSymbol)
-
-      cnode = new ClassNode1()
-
-      initJClass(cnode)
-
-      val cd = if (isCZStaticModule) {
-        // Move statements from the primary constructor following the superclass constructor call to
-        // a newly synthesised tree representing the "<clinit>", which also assigns the MODULE$ field.
-        // Because the assigments to both the module instance fields, and the fields of the module itself
-        // are in the <clinit>, these fields can be static + final.
-
-        // Should we do this transformation earlier, say in Constructors? Or would that just cause
-        // pain for scala-{js, native}?
-        //
-        // @sjrd (https://github.com/scala/scala3/pull/9181#discussion_r457458205):
-        // moving that before the back-end would make things significantly more complicated for
-        // Scala.js and Native. Both have a first-class concept of ModuleClass, and encode the
-        // singleton pattern of MODULE$ in a completely different way. In the Scala.js IR, there
-        // even isn't anything that corresponds to MODULE$ per se.
-        //
-        // So if you move this before the back-end, then Scala.js and Scala Native will have to
-        // reverse all the effects of this transformation, which would be counter-productive.
-
-
-        // TODO: remove `!f.name.is(LazyBitMapName)` once we change lazy val encoding
-        //       https://github.com/scala/scala3/issues/7140
-        //
-        // Lazy val encoding assumes bitmap fields are non-static
-        //
-        // See `tests/run/given-var.scala`
-        //
-
-        // !!! Part of this logic is duplicated in JSCodeGen.genCompilationUnit
-        claszSymbol.info.decls.foreach { f =>
-          if f.isField && !f.name.is(LazyBitMapName) then
-            f.setFlag(JavaStatic)
-        }
-
-        val (clinits, body) = impl.body.partition(stat => stat.isInstanceOf[DefDef] && stat.symbol.isStaticConstructor)
-
-        val (uptoSuperStats, remainingConstrStats) = splitAtSuper(impl.constr.rhs.asInstanceOf[Block].stats)
-        val clInitSymbol: TermSymbol =
-          if (clinits.nonEmpty) clinits.head.symbol.asTerm
-          else newSymbol(
-            claszSymbol,
-            nme.STATIC_CONSTRUCTOR,
-            JavaStatic | Method,
-            MethodType(Nil)(_ => Nil, _ => defn.UnitType),
-            privateWithin = NoSymbol,
-            coord = claszSymbol.coord
-          )
-
-        val moduleField = newSymbol(
-            claszSymbol,
-            str.MODULE_INSTANCE_FIELD.toTermName,
-            JavaStatic | Final,
-            claszSymbol.typeRef,
-            privateWithin = NoSymbol,
-            coord = claszSymbol.coord
-          ).entered
-
-        val thisMap = new TreeMap {
-          override def transform(tree: Tree)(using Context) = {
-            val tp = tree.tpe.substThis(claszSymbol.asClass, claszSymbol.sourceModule.termRef)
-            tree.withType(tp) match {
-              case tree: This if tree.symbol == claszSymbol =>
-                ref(claszSymbol.sourceModule)
-              case tree =>
-                super.transform(tree)
-            }
-          }
-        }
-
-        def rewire(stat: Tree) = thisMap.transform(stat).changeOwner(claszSymbol.primaryConstructor, clInitSymbol)
-
-        val callConstructor = New(claszSymbol.typeRef).select(claszSymbol.primaryConstructor).appliedToTermArgs(Nil)
-        val assignModuleField = Assign(ref(moduleField), callConstructor)
-        val remainingConstrStatsSubst = remainingConstrStats.map(rewire)
-        val clinit = clinits match {
-          case (ddef: DefDef) :: _ =>
-            cpy.DefDef(ddef)(rhs = Block(ddef.rhs :: assignModuleField :: remainingConstrStatsSubst, unitLiteral))
-          case _ =>
-            DefDef(clInitSymbol, Block(assignModuleField :: remainingConstrStatsSubst, unitLiteral))
-        }
-
-        val constr2 = {
-          val rhs = Block(uptoSuperStats, impl.constr.rhs.asInstanceOf[Block].expr)
-          cpy.DefDef(impl.constr)(rhs = rhs)
-        }
-
-        val impl2 = cpy.Template(impl)(constr = constr2, body = clinit :: body)
-        cpy.TypeDef(cd0)(rhs = impl2)
-      } else cd0
-
-      val hasStaticCtor = isCZStaticModule || cd.symbol.info.decls.exists(_.isStaticConstructor)
-      if (!hasStaticCtor && isCZParcelable) fabricateStaticInitAndroid()
-
-      val optSerial: Option[Long] =
-        claszSymbol.getAnnotation(defn.SerialVersionUIDAnnot).flatMap { annot =>
-          if (claszSymbol.is(Trait)) {
-            report.warning("@SerialVersionUID does nothing on a trait", annot.tree.sourcePos)
-            None
-          } else {
-            val vuid = annot.argumentConstant(0).map(_.longValue)
-            if (vuid.isEmpty)
-              report.error("The argument passed to @SerialVersionUID must be a constant",
-                annot.argument(0).getOrElse(annot.tree).sourcePos)
-            vuid
-          }
-        }
-      if (optSerial.isDefined) { addSerialVUID(optSerial.get, cnode)}
-
-      addClassFields()
-      gen(cd.rhs)
-
-      if (AsmUtils.traceClassEnabled && cnode.name.contains(AsmUtils.traceClassPattern))
-        AsmUtils.traceClass(cnode)
-
-      cnode.innerClasses
-      assert(cd.symbol == claszSymbol, "Someone messed up BCodePhase.claszSymbol during genPlainClass().")
-
-    } // end of method genPlainClass()
-
-    /*
-     * must-single-thread
-     */
-    private def initJClass(jclass: asm.ClassVisitor): Unit = {
-
-      val ps = claszSymbol.info.parents
-      val superClass: String = if (ps.isEmpty) ObjectRef.internalName else internalName(ps.head.typeSymbol)
-      val interfaceNames0 = classBTypeFromSymbol(claszSymbol).info.interfaces.map(_.internalName)
-      /* To avoid deadlocks when combining objects, lambdas and multi-threading,
-       * lambdas in objects are compiled to instance methods of the module class
-       * instead of static methods (see tests/run/deadlock.scala and
-       * https://github.com/scala/scala-dev/issues/195 for details).
-       * This has worked well for us so far but this is problematic for
-       * serialization: serializing a lambda requires serializing all the values
-       * it captures, if this lambda is in an object, this means serializing the
-       * enclosing object, which fails if the object does not extend
-       * Serializable.
-       * Because serializing objects is basically free since #5775, it seems like
-       * the simplest solution is to simply make all objects Serializable, this
-       * certainly seems preferable to deadlocks.
-       * This cannot be done earlier because Scala.js would not like it (#9596).
-       */
-      val interfaceNames =
-        if (claszSymbol.is(ModuleClass) && !interfaceNames0.contains("java/io/Serializable"))
-          interfaceNames0 :+ "java/io/Serializable"
-        else
-          interfaceNames0
-
-      val flags = javaFlags(claszSymbol)
-
-      val thisSignature = getGenericSignature(claszSymbol, claszSymbol.owner)
-      cnode.visit(classfileVersion, flags,
-                  thisName, thisSignature,
-                  superClass, interfaceNames.toArray)
-
-      if (emitSource) {
-        cnode.visitSource(cunit.source.file.name, null /* SourceDebugExtension */)
-      }
-
-      enclosingMethodAttribute(claszSymbol, internalName, asmMethodType(_).descriptor) match {
-        case Some(EnclosingMethodEntry(className, methodName, methodDescriptor)) =>
-          cnode.visitOuterClass(className, methodName, methodDescriptor)
-        case _ => ()
-      }
-
-      val ssa = None // TODO: inlined form `getAnnotPickle(thisName, claszSymbol)`. Should something be done on Dotty?
-      cnode.visitAttribute(if (ssa.isDefined) pickleMarkerLocal else pickleMarkerForeign)
-      emitAnnotations(cnode, claszSymbol.annotations ++ ssa)
-
-      if (!isCZStaticModule && !isCZParcelable) {
-        val skipStaticForwarders = (claszSymbol.is(Module) || ctx.settings.XnoForwarders.value)
-        if (!skipStaticForwarders) {
-          val lmoc = claszSymbol.companionModule
-          // add static forwarders if there are no name conflicts; see bugs #363 and #1735
-          if (lmoc != NoSymbol) {
-            // it must be a top level class (name contains no $s)
-            val isCandidateForForwarders =  (lmoc.is(Module)) && lmoc.isStatic
-            if (isCandidateForForwarders) {
-              report.log(s"Adding static forwarders from '$claszSymbol' to implementations in '$lmoc'")
-              addForwarders(cnode, thisName, lmoc.moduleClass)
-            }
-          }
-        }
-
-      }
-
-      // the invoker is responsible for adding a class-static constructor.
-
-    } // end of method initJClass
-
-    /*
-     * must-single-thread
-     */
-    private def fabricateStaticInitAndroid(): Unit = {
-
-      val clinit: asm.MethodVisitor = cnode.visitMethod(
-        GenBCodeOps.PublicStatic, // TODO confirm whether we really don't want ACC_SYNTHETIC nor ACC_DEPRECATED
-        CLASS_CONSTRUCTOR_NAME,
-        "()V",
-        null, // no java-generic-signature
-        null  // no throwable exceptions
-      )
-      clinit.visitCode()
-
-      legacyAddCreatorCode(clinit, cnode, thisName)
-
-      clinit.visitInsn(asm.Opcodes.RETURN)
-      clinit.visitMaxs(0, 0) // just to follow protocol, dummy arguments
-      clinit.visitEnd()
-    }
-
-    def addClassFields(): Unit = {
-      /*  Non-method term members are fields, except for module members. Module
-       *  members can only happen on .NET (no flatten) for inner traits. There,
-       *  a module symbol is generated (transformInfo in mixin) which is used
-       *  as owner for the members of the implementation class (so that the
-       *  backend emits them as static).
-       *  No code is needed for this module symbol.
-       */
-      for (f <- claszSymbol.info.decls.filter(p => p.isTerm && !p.is(Method))) {
-        val javagensig = getGenericSignature(f, claszSymbol)
-        val flags = javaFieldFlags(f)
-
-        assert(!f.isStaticMember || !claszSymbol.isInterface || !f.is(Mutable),
-          s"interface $claszSymbol cannot have non-final static field $f")
-
-        val jfield = new asm.tree.FieldNode(
-          flags,
-          f.javaSimpleName,
-          symInfoTK(f).descriptor,
-          javagensig,
-          null // no initial value
-        )
-        cnode.fields.add(jfield)
-        emitAnnotations(jfield, f.annotations)
-      }
-
-    } // end of method addClassFields()
-
-    // current method
-    var mnode: MethodNode1         = null
-    var jMethodName: String        = null
-    var isMethSymStaticCtor        = false
-    var returnType: BType          = null
-    var methSymbol: Symbol         = null
-    // used by genLoadTry() and genSynchronized()
-    var earlyReturnVar: Symbol     = null
-    var shouldEmitCleanup          = false
-    // line numbers
-    var lastEmittedLineNr          = -1
-
-    object bc extends JCodeMethodN {
-      override def jmethod = PlainSkelBuilder.this.mnode
-    }
-
-    /* ---------------- Part 1 of program points, ie Labels in the ASM world ---------------- */
-
-    /*
-     *  A jump is represented as a Return node whose `from` symbol denotes a Labeled's Bind node, the target of the jump.
-     *  The `jumpDest` map is used to find the `LoadDestination` at the end of the `Labeled` block, as well as the
-     *  corresponding expected type. The `LoadDestination` can never be `FallThrough` here.
-     */
-    var jumpDest: immutable.Map[ /* Labeled */ Symbol, (BType, LoadDestination) ] = null
-    def registerJumpDest(labelSym: Symbol, expectedType: BType, dest: LoadDestination): Unit = {
-      assert(labelSym.is(Label), s"trying to register a jump-dest for a non-label symbol, at: ${labelSym.span}")
-      assert(dest != LoadDestination.FallThrough, s"trying to register a FallThrough dest for label, at: ${labelSym.span}")
-      assert(!jumpDest.contains(labelSym), s"trying to register a second jump-dest for label, at: ${labelSym.span}")
-      jumpDest += (labelSym -> (expectedType, dest))
-    }
-    def findJumpDest(labelSym: Symbol): (BType, LoadDestination) = {
-      assert(labelSym.is(Label), s"trying to map a non-label symbol to an asm.Label, at: ${labelSym.span}")
-      jumpDest.getOrElse(labelSym, {
-        abort(s"unknown label symbol, for label at: ${labelSym.span}")
-      })
-    }
-
-    /*
-     *  A program point may be lexically nested (at some depth)
-     *    (a) in the try-clause of a try-with-finally expression
-     *    (b) in a synchronized block.
-     *  Each of the constructs above establishes a "cleanup block" to execute upon
-     *  both normal-exit, early-return, and abrupt-termination of the instructions it encloses.
-     *
-     *  The `cleanups` LIFO queue represents the nesting of active (for the current program point)
-     *  pending cleanups. For each such cleanup an asm.Label indicates the start of its cleanup-block.
-     *  At any given time during traversal of the method body,
-     *  the head of `cleanups` denotes the cleanup-block for the closest enclosing try-with-finally or synchronized-expression.
-     *
-     *  `cleanups` is used:
-     *
-     *    (1) upon visiting a Return statement.
-     *        In case of pending cleanups, we can't just emit a RETURN instruction, but must instead:
-     *          - store the result (if any) in `earlyReturnVar`, and
-     *          - jump to the next pending cleanup.
-     *        See `genReturn()`
-     *
-     *    (2) upon emitting a try-with-finally or a synchronized-expr,
-     *        In these cases, the targets of the above jumps are emitted,
-     *        provided an early exit was actually encountered somewhere in the protected clauses.
-     *        See `genLoadTry()` and `genSynchronized()`
-     *
-     *  The code thus emitted for jumps and targets covers the early-return case.
-     *  The case of abrupt (ie exceptional) termination is covered by exception handlers
-     *  emitted for that purpose as described in `genLoadTry()` and `genSynchronized()`.
-     */
-    var cleanups: List[asm.Label] = Nil
-    def registerCleanup(finCleanup: asm.Label): Unit = {
-      if (finCleanup != null) { cleanups = finCleanup :: cleanups }
-    }
-    def unregisterCleanup(finCleanup: asm.Label): Unit = {
-      if (finCleanup != null) {
-        assert(cleanups.head eq finCleanup,
-               s"Bad nesting of cleanup operations: $cleanups trying to unregister: $finCleanup")
-        cleanups = cleanups.tail
-      }
-    }
-
-    /* ---------------- local variables and params ---------------- */
-
-    case class Local(tk: BType, name: String, idx: Int, isSynth: Boolean)
-
-    /*
-     * Bookkeeping for method-local vars and method-params.
-     *
-     * TODO: use fewer slots. local variable slots are never re-used in separate blocks.
-     * In the following example, x and y could use the same slot.
-     *   def foo() = {
-     *     { val x = 1 }
-     *     { val y = "a" }
-     *   }
-     */
-    object locals {
-
-      private val slots = mutable.AnyRefMap.empty[Symbol, Local] // (local-or-param-sym -> Local(BType, name, idx, isSynth))
-
-      private var nxtIdx = -1 // next available index for local-var
-
-      def reset(isStaticMethod: Boolean): Unit = {
-        slots.clear()
-        nxtIdx = if (isStaticMethod) 0 else 1
-      }
-
-      def contains(locSym: Symbol): Boolean = { slots.contains(locSym) }
-
-      def apply(locSym: Symbol): Local = { slots.apply(locSym) }
-
-      /* Make a fresh local variable, ensuring a unique name.
-       * The invoker must make sure inner classes are tracked for the sym's tpe.
-       */
-      def makeLocal(tk: BType, name: String, tpe: Type, pos: Span): Symbol = {
-
-        val locSym = newSymbol(methSymbol, name.toTermName, Synthetic, tpe, NoSymbol, pos)
-        makeLocal(locSym, tk)
-        locSym
-      }
-
-      def makeLocal(locSym: Symbol): Local = {
-        makeLocal(locSym, symInfoTK(locSym))
-      }
-
-      def getOrMakeLocal(locSym: Symbol): Local = {
-        // `getOrElse` below has the same effect as `getOrElseUpdate` because `makeLocal()` adds an entry to the `locals` map.
-        slots.getOrElse(locSym, makeLocal(locSym))
-      }
-
-      def reuseLocal(sym: Symbol, loc: Local): Unit =
-        val existing = slots.put(sym, loc)
-        if (existing.isDefined)
-          report.error("attempt to create duplicate local var.", ctx.source.atSpan(sym.span))
-
-      def reuseThisSlot(sym: Symbol): Unit =
-        reuseLocal(sym, Local(symInfoTK(sym), sym.javaSimpleName, 0, sym.is(Synthetic)))
-
-      private def makeLocal(sym: Symbol, tk: BType): Local = {
-        assert(nxtIdx != -1, "not a valid start index")
-        val loc = Local(tk, sym.javaSimpleName, nxtIdx, sym.is(Synthetic))
-        val existing = slots.put(sym, loc)
-        if (existing.isDefined)
-          report.error("attempt to create duplicate local var.", ctx.source.atSpan(sym.span))
-        assert(tk.size > 0, "makeLocal called for a symbol whose type is Unit.")
-        nxtIdx += tk.size
-        loc
-      }
-
-      // not to be confused with `fieldStore` and `fieldLoad` which also take a symbol but a field-symbol.
-      def store(locSym: Symbol): Unit = {
-        val Local(tk, _, idx, _) = slots(locSym)
-        bc.store(idx, tk)
-      }
-
-      def load(locSym: Symbol): Unit = {
-        val Local(tk, _, idx, _) = slots(locSym)
-        bc.load(idx, tk)
-      }
-
-    }
-
-    /* ---------------- Part 2 of program points, ie Labels in the ASM world ---------------- */
-
-    // bookkeeping the scopes of non-synthetic local vars, to emit debug info (`emitVars`).
-    var varsInScope: List[(Symbol, asm.Label)] = null // (local-var-sym -> start-of-scope)
-
-    // helpers around program-points.
-    def lastInsn: asm.tree.AbstractInsnNode = mnode.instructions.getLast
-    def currProgramPoint(): asm.Label = {
-      lastInsn match {
-        case labnode: asm.tree.LabelNode => labnode.getLabel
-        case _ =>
-          val pp = new asm.Label
-          mnode visitLabel pp
-          pp
-      }
-    }
-    def markProgramPoint(lbl: asm.Label): Unit = {
-      val skip = (lbl == null) || isAtProgramPoint(lbl)
-      if (!skip) { mnode visitLabel lbl }
-    }
-    def isAtProgramPoint(lbl: asm.Label): Boolean = {
-      def getNonLineNumberNode(a: asm.tree.AbstractInsnNode): asm.tree.AbstractInsnNode  = a match {
-        case a: asm.tree.LineNumberNode => getNonLineNumberNode(a.getPrevious) // line numbers aren't part of code itself
-        case _ => a
-      }
-      (getNonLineNumberNode(lastInsn) match {
-        case labnode: asm.tree.LabelNode => (labnode.getLabel == lbl);
-        case _ => false } )
-    }
-    def lineNumber(tree: Tree): Unit = {
-      if (!emitLines || !tree.span.exists) return;
-      val nr = ctx.source.offsetToLine(tree.span.point) + 1
-      if (nr != lastEmittedLineNr) {
-        lastEmittedLineNr = nr
-        lastInsn match {
-          case lnn: asm.tree.LineNumberNode =>
-            // overwrite previous landmark as no instructions have been emitted for it
-            lnn.line = nr
-          case _ =>
-            mnode.visitLineNumber(nr, currProgramPoint())
-        }
-      }
-    }
-
-    // on entering a method
-    def resetMethodBookkeeping(dd: DefDef) = {
-      val rhs = dd.rhs
-      locals.reset(isStaticMethod = methSymbol.isStaticMember)
-      jumpDest = immutable.Map.empty
-
-      // check previous invocation of genDefDef exited as many varsInScope as it entered.
-      assert(varsInScope == null, "Unbalanced entering/exiting of GenBCode's genBlock().")
-      // check previous invocation of genDefDef unregistered as many cleanups as it registered.
-      assert(cleanups == Nil, "Previous invocation of genDefDef didn't unregister as many cleanups as it registered.")
-      earlyReturnVar      = null
-      shouldEmitCleanup   = false
-
-      lastEmittedLineNr = -1
-    }
-
-    /* ---------------- top-down traversal invoking ASM Tree API along the way ---------------- */
-
-    def gen(tree: Tree): Unit = {
-      tree match {
-        case tpd.EmptyTree => ()
-
-        case ValDef(name, tpt, rhs) => () // fields are added in `genPlainClass()`, via `addClassFields()`
-
-        case dd: DefDef =>
-          /* First generate a static forwarder if this is a non-private trait
-           * trait method. This is required for super calls to this method, which
-           * go through the static forwarder in order to work around limitations
-           * of the JVM.
-           *
-           * For the $init$ method, we must not leave it as a default method, but
-           * instead we must put the whole body in the static method. If we leave
-           * it as a default method, Java classes cannot extend Scala classes that
-           * extend several Scala traits, since they then inherit unrelated default
-           * $init$ methods. See #8599. scalac does the same thing.
-           *
-           * In theory, this would go in a separate MiniPhase, but it would have to
-           * sit in a MegaPhase of its own between GenSJSIR and GenBCode, so the cost
-           * is not worth it. We directly do it in this back-end instead, which also
-           * kind of makes sense because it is JVM-specific.
-           */
-          val sym = dd.symbol
-          val needsStaticImplMethod =
-            claszSymbol.isInterface && !dd.rhs.isEmpty && !sym.isPrivate && !sym.isStaticMember
-          if needsStaticImplMethod then
-            if sym.name == nme.TRAIT_CONSTRUCTOR then
-              genTraitConstructorDefDef(dd)
-            else
-              genStaticForwarderForDefDef(dd)
-              genDefDef(dd)
-          else
-            genDefDef(dd)
-
-        case tree: Template =>
-          val body =
-            if (tree.constr.rhs.isEmpty) tree.body
-            else tree.constr :: tree.body
-          body foreach gen
-
-        case _ => abort(s"Illegal tree in gen: $tree")
-      }
-    }
-
-    /*
-     * must-single-thread
-     */
-    def initJMethod(flags: Int, params: List[Symbol]): Unit = {
-
-      val jgensig = getGenericSignature(methSymbol, claszSymbol)
-      val (excs, others) = methSymbol.annotations.partition(_.symbol eq defn.ThrowsAnnot)
-      val thrownExceptions: List[String] = getExceptions(excs)
-
-      val bytecodeName =
-        if (isMethSymStaticCtor) CLASS_CONSTRUCTOR_NAME
-        else jMethodName
-
-      val mdesc = asmMethodType(methSymbol).descriptor
-      mnode = cnode.visitMethod(
-        flags,
-        bytecodeName,
-        mdesc,
-        jgensig,
-        mkArrayS(thrownExceptions)
-      ).asInstanceOf[MethodNode1]
-
-      // TODO param names: (m.params map (p => javaName(p.sym)))
-
-      emitAnnotations(mnode, others)
-      emitParamNames(mnode, params)
-      emitParamAnnotations(mnode, params.map(_.annotations))
-
-    } // end of method initJMethod
-
-    private def genTraitConstructorDefDef(dd: DefDef): Unit =
-      val statifiedDef = makeStatifiedDefDef(dd)
-      genDefDef(statifiedDef)
-
-    /** Creates a copy of the given DefDef that is static and where an explicit
-     *  self parameter represents the original `this` value.
-     *
-     *  Example: from
-     *  {{{
-     *  trait Enclosing {
-     *    def foo(x: Int): String = this.toString() + x
-     *  }
-     *  }}}
-     *  the statified version of `foo` would be
-     *  {{{
-     *  static def foo($self: Enclosing, x: Int): String = $self.toString() + x
-     *  }}}
-     */
-    private def makeStatifiedDefDef(dd: DefDef): DefDef =
-      val origSym = dd.symbol.asTerm
-      val newSym = makeStatifiedDefSymbol(origSym, origSym.name)
-      tpd.DefDef(newSym, { paramRefss =>
-        val selfParamRef :: regularParamRefs = paramRefss.head: @unchecked
-        val enclosingClass = origSym.owner.asClass
-        new TreeTypeMap(
-          typeMap = _.substThis(enclosingClass, selfParamRef.symbol.termRef)
-            .subst(dd.termParamss.head.map(_.symbol), regularParamRefs.map(_.symbol.termRef)),
-          treeMap = {
-            case tree: This if tree.symbol == enclosingClass => selfParamRef
-            case tree => tree
-          },
-          oldOwners = origSym :: Nil,
-          newOwners = newSym :: Nil
-        ).transform(dd.rhs)
-      })
-
-    private def genStaticForwarderForDefDef(dd: DefDef): Unit =
-      val forwarderDef = makeStaticForwarder(dd)
-      genDefDef(forwarderDef)
-
-    /* Generates a synthetic static forwarder for a trait method.
-     * For a method such as
-     *   def foo(...args: Ts): R
-     * in trait X, we generate the following method:
-     *   static def foo$($this: X, ...args: Ts): R =
-     *     invokespecial $this.X::foo(...args)
-     * We force an invokespecial with the attachment UseInvokeSpecial. It is
-     * necessary to make sure that the call will not follow overrides of foo()
-     * in subtraits and subclasses, since the whole point of this forward is to
-     * encode super calls.
-     */
-    private def makeStaticForwarder(dd: DefDef): DefDef =
-      val origSym = dd.symbol.asTerm
-      val name = traitSuperAccessorName(origSym).toTermName
-      val sym = makeStatifiedDefSymbol(origSym, name)
-      tpd.DefDef(sym, { paramss =>
-        val params = paramss.head
-        tpd.Apply(params.head.select(origSym), params.tail)
-          .withAttachment(BCodeHelpers.UseInvokeSpecial, ())
-      })
-
-    private def makeStatifiedDefSymbol(origSym: TermSymbol, name: TermName): TermSymbol =
-      val info = origSym.info match
-        case mt: MethodType =>
-          MethodType(nme.SELF :: mt.paramNames, origSym.owner.typeRef :: mt.paramInfos, mt.resType)
-      origSym.copy(
-        name = name.toTermName,
-        flags = Method | JavaStatic,
-        info = info
-      ).asTerm
-
-    def genDefDef(dd: DefDef): Unit = {
-      val rhs = dd.rhs
-      val vparamss = dd.termParamss
-      // the only method whose implementation is not emitted: getClass()
-      if (dd.symbol eq defn.Any_getClass) { return }
-      assert(mnode == null, "GenBCode detected nested method.")
-
-      methSymbol  = dd.symbol
-      jMethodName = methSymbol.javaSimpleName
-      returnType  = asmMethodType(dd.symbol).returnType
-      isMethSymStaticCtor = methSymbol.isStaticConstructor
-
-      resetMethodBookkeeping(dd)
-
-      // add method-local vars for params
-
-      assert(vparamss.isEmpty || vparamss.tail.isEmpty, s"Malformed parameter list: $vparamss")
-      val params = if (vparamss.isEmpty) Nil else vparamss.head
-      for (p <- params) { locals.makeLocal(p.symbol) }
-      // debug assert((params.map(p => locals(p.symbol).tk)) == asmMethodType(methSymbol).getArgumentTypes.toList, "debug")
-
-      if (params.size > MaximumJvmParameters) {
-        // SI-7324
-        report.error(em"Platform restriction: a parameter list's length cannot exceed $MaximumJvmParameters.", ctx.source.atSpan(methSymbol.span))
-        return
-      }
-
-      val isNative         = methSymbol.hasAnnotation(NativeAttr)
-      val isAbstractMethod = (methSymbol.is(Deferred) || (methSymbol.owner.isInterface && ((methSymbol.is(Deferred))  || methSymbol.isClassConstructor)))
-      val flags =
-        import GenBCodeOps.addFlagIf
-        javaFlags(methSymbol)
-          .addFlagIf(isAbstractMethod, asm.Opcodes.ACC_ABSTRACT)
-          .addFlagIf(false /*methSymbol.isStrictFP*/, asm.Opcodes.ACC_STRICT)
-          .addFlagIf(isNative, asm.Opcodes.ACC_NATIVE) // native methods of objects are generated in mirror classes
-
-      // TODO needed? for(ann <- m.symbol.annotations) { ann.symbol.initialize }
-      val paramSyms = params.map(_.symbol)
-      initJMethod(flags, paramSyms)
-
-
-      if (!isAbstractMethod && !isNative) {
-        // #14773 Reuse locals slots for tailrec-generated mutable vars
-        val trimmedRhs: Tree =
-          @tailrec def loop(stats: List[Tree]): List[Tree] =
-            stats match
-              case (tree @ ValDef(TailLocalName(_, _), _, _)) :: rest if tree.symbol.isAllOf(Mutable | Synthetic) =>
-                tree.rhs match
-                  case This(_) =>
-                    locals.reuseThisSlot(tree.symbol)
-                    loop(rest)
-                  case rhs: Ident if paramSyms.contains(rhs.symbol) =>
-                    locals.reuseLocal(tree.symbol, locals(rhs.symbol))
-                    loop(rest)
-                  case _ =>
-                    stats
-              case _ =>
-                stats
-          end loop
-
-          rhs match
-            case Block(stats, expr) =>
-              val trimmedStats = loop(stats)
-              if trimmedStats eq stats then
-                rhs
-              else
-                Block(trimmedStats, expr)
-            case _ =>
-              rhs
-        end trimmedRhs
-
-        def emitNormalMethodBody(): Unit = {
-          val veryFirstProgramPoint = currProgramPoint()
-
-          if trimmedRhs == tpd.EmptyTree then
-            report.error(
-              em"Concrete method has no definition: $dd${
-                  if (ctx.settings.Ydebug.value) "(found: " + methSymbol.owner.info.decls.toList.mkString(", ") + ")"
-                  else ""}",
-              ctx.source.atSpan(NoSpan)
-            )
-          else
-            genLoadTo(trimmedRhs, returnType, LoadDestination.Return)
-
-          if (emitVars) {
-            // add entries to LocalVariableTable JVM attribute
-            val onePastLastProgramPoint = currProgramPoint()
-            val hasStaticBitSet = ((flags & asm.Opcodes.ACC_STATIC) != 0)
-            if (!hasStaticBitSet) {
-              mnode.visitLocalVariable(
-                "this",
-                "L" + thisName + ";",
-                null,
-                veryFirstProgramPoint,
-                onePastLastProgramPoint,
-                0
-              )
-            }
-            for (p <- params) { emitLocalVarScope(p.symbol, veryFirstProgramPoint, onePastLastProgramPoint, force = true) }
-          }
-
-          if (isMethSymStaticCtor) { appendToStaticCtor(dd) }
-        } // end of emitNormalMethodBody()
-
-        lineNumber(rhs)
-        emitNormalMethodBody()
-
-        // Note we don't invoke visitMax, thus there are no FrameNode among mnode.instructions.
-        // The only non-instruction nodes to be found are LabelNode and LineNumberNode.
-      }
-
-      if (AsmUtils.traceMethodEnabled && mnode.name.contains(AsmUtils.traceMethodPattern))
-        AsmUtils.traceMethod(mnode)
-
-      mnode = null
-    } // end of method genDefDef()
-
-    /*
-     *  must-single-thread
-     *
-     *  TODO document, explain interplay with `fabricateStaticInitAndroid()`
-     */
-    private def appendToStaticCtor(dd: DefDef): Unit = {
-
-      def insertBefore(
-            location: asm.tree.AbstractInsnNode,
-            i0: asm.tree.AbstractInsnNode,
-            i1: asm.tree.AbstractInsnNode): Unit = {
-        if (i0 != null) {
-          mnode.instructions.insertBefore(location, i0.clone(null))
-          mnode.instructions.insertBefore(location, i1.clone(null))
-        }
-      }
-
-      // collect all return instructions
-      var rets: List[asm.tree.AbstractInsnNode] = Nil
-      mnode foreachInsn { i => if (i.getOpcode() == asm.Opcodes.RETURN) { rets ::= i  } }
-      if (rets.isEmpty) { return }
-
-      var insnParcA: asm.tree.AbstractInsnNode = null
-      var insnParcB: asm.tree.AbstractInsnNode = null
-      // android creator code
-      if (isCZParcelable) {
-        // add a static field ("CREATOR") to this class to cache android.os.Parcelable$Creator
-        val andrFieldDescr = classBTypeFromSymbol(AndroidCreatorClass).descriptor
-        cnode.visitField(
-          asm.Opcodes.ACC_STATIC | asm.Opcodes.ACC_FINAL,
-          "CREATOR",
-          andrFieldDescr,
-          null,
-          null
-        )
-        // INVOKESTATIC CREATOR(): android.os.Parcelable$Creator; -- TODO where does this Android method come from?
-        val callee = claszSymbol.companionModule.info.member(androidFieldName).symbol
-        val jowner = internalName(callee.owner)
-        val jname  = callee.javaSimpleName
-        val jtype  = asmMethodType(callee).descriptor
-        insnParcA  = new asm.tree.MethodInsnNode(asm.Opcodes.INVOKESTATIC, jowner, jname, jtype, false)
-        // PUTSTATIC `thisName`.CREATOR;
-        insnParcB  = new asm.tree.FieldInsnNode(asm.Opcodes.PUTSTATIC, thisName, "CREATOR", andrFieldDescr)
-      }
-
-      // insert a few instructions for initialization before each return instruction
-      for(r <- rets) {
-        insertBefore(r, insnParcA, insnParcB)
-      }
-
-    }
-
-    def emitLocalVarScope(sym: Symbol, start: asm.Label, end: asm.Label, force: Boolean = false): Unit = {
-      val Local(tk, name, idx, isSynth) = locals(sym)
-      if (force || !isSynth) {
-        mnode.visitLocalVariable(name, tk.descriptor, null, start, end, idx)
-      }
-    }
-
-    def genLoadTo(tree: Tree, expectedType: BType, dest: LoadDestination): Unit
-
-  } // end of class PlainSkelBuilder
-
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/BCodeSyncAndTry.scala b/tests/pos-with-compiler-cc/backend/jvm/BCodeSyncAndTry.scala
deleted file mode 100644
index b5ed27511e7e..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/BCodeSyncAndTry.scala
+++ /dev/null
@@ -1,426 +0,0 @@
-package dotty.tools
-package backend
-package jvm
-
-import scala.language.unsafeNulls
-
-import scala.collection.immutable
-import scala.tools.asm
-
-import dotty.tools.dotc.CompilationUnit
-import dotty.tools.dotc.core.StdNames.nme
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.ast.tpd
-
-/*
- *
- *  @author  Miguel Garcia, http://lamp.epfl.ch/~magarcia/ScalaCompilerCornerReloaded/
- *  @version 1.0
- *
- */
-trait BCodeSyncAndTry extends BCodeBodyBuilder {
-  import int.given
-  import tpd._
-  import bTypes._
-  import coreBTypes._
-  /*
-   * Functionality to lower `synchronized` and `try` expressions.
-   */
-  abstract class SyncAndTryBuilder(cunit: CompilationUnit) extends PlainBodyBuilder(cunit) {
-
-    def genSynchronized(tree: Apply, expectedType: BType): BType = (tree: @unchecked) match {
-      case Apply(TypeApply(fun, _), args) =>
-      val monitor = locals.makeLocal(ObjectRef, "monitor", defn.ObjectType, tree.span)
-      val monCleanup = new asm.Label
-
-      // if the synchronized block returns a result, store it in a local variable.
-      // Just leaving it on the stack is not valid in MSIL (stack is cleaned when leaving try-blocks).
-      val hasResult = (expectedType != UNIT)
-      val monitorResult: Symbol = if (hasResult) locals.makeLocal(tpeTK(args.head), "monitorResult", defn.ObjectType, tree.span) else null
-
-      /* ------ (1) pushing and entering the monitor, also keeping a reference to it in a local var. ------ */
-      genLoadQualifier(fun)
-      bc dup ObjectRef
-      locals.store(monitor)
-      emit(asm.Opcodes.MONITORENTER)
-
-      /* ------ (2) Synchronized block.
-       *            Reached by fall-through from (1).
-       *            Protected by:
-       *            (2.a) the EH-version of the monitor-exit, and
-       *            (2.b) whatever protects the whole synchronized expression.
-       * ------
-       */
-      val startProtected = currProgramPoint()
-      registerCleanup(monCleanup)
-      genLoad(args.head, expectedType /* toTypeKind(tree.tpe.resultType) */)
-      unregisterCleanup(monCleanup)
-      if (hasResult) { locals.store(monitorResult) }
-      nopIfNeeded(startProtected)
-      val endProtected = currProgramPoint()
-
-      /* ------ (3) monitor-exit after normal, non-early-return, termination of (2).
-       *            Reached by fall-through from (2).
-       *            Protected by whatever protects the whole synchronized expression.
-       * ------
-       */
-      locals.load(monitor)
-      emit(asm.Opcodes.MONITOREXIT)
-      if (hasResult) { locals.load(monitorResult) }
-      val postHandler = new asm.Label
-      bc goTo postHandler
-
-      /* ------ (4) exception-handler version of monitor-exit code.
-       *            Reached upon abrupt termination of (2).
-       *            Protected by whatever protects the whole synchronized expression.
-       *            null => "any" exception in bytecode, like we emit for finally.
-       *            Important not to use j/l/Throwable which dooms the method to a life of interpretation! (SD-233)
-       * ------
-       */
-      protect(startProtected, endProtected, currProgramPoint(), null)
-      locals.load(monitor)
-      emit(asm.Opcodes.MONITOREXIT)
-      emit(asm.Opcodes.ATHROW)
-
-      /* ------ (5) cleanup version of monitor-exit code.
-       *            Reached upon early-return from (2).
-       *            Protected by whatever protects the whole synchronized expression.
-       * ------
-       */
-      if (shouldEmitCleanup) {
-        markProgramPoint(monCleanup)
-        locals.load(monitor)
-        emit(asm.Opcodes.MONITOREXIT)
-        pendingCleanups()
-      }
-
-      /* ------ (6) normal exit of the synchronized expression.
-       *            Reached after normal, non-early-return, termination of (3).
-       *            Protected by whatever protects the whole synchronized expression.
-       * ------
-       */
-      mnode visitLabel postHandler
-
-      lineNumber(tree)
-
-      expectedType
-    }
-
-    /*
-     *  Detects whether no instructions have been emitted since label `lbl` and if so emits a NOP.
-     *  Useful to avoid emitting an empty try-block being protected by exception handlers,
-     *  which results in "java.lang.ClassFormatError: Illegal exception table range". See SI-6102.
-     */
-    def nopIfNeeded(lbl: asm.Label): Unit = {
-      val noInstructionEmitted = isAtProgramPoint(lbl)
-      if (noInstructionEmitted) { emit(asm.Opcodes.NOP) }
-    }
-
-    /*
-     *  Emitting try-catch is easy, emitting try-catch-finally not quite so.
-     *  A finally-block (which always has type Unit, thus leaving the operand stack unchanged)
-     *  affects control-transfer from protected regions, as follows:
-     *
-     *    (a) `return` statement:
-     *
-     *        First, the value to return (if any) is evaluated.
-     *        Afterwards, all enclosing finally-blocks are run, from innermost to outermost.
-     *        Only then is the return value (if any) returned.
-     *
-     *        Some terminology:
-     *          (a.1) Executing a return statement that is protected
-     *                by one or more finally-blocks is called "early return"
-     *          (a.2) the chain of code sections (a code section for each enclosing finally-block)
-     *                to run upon early returns is called "cleanup chain"
-     *
-     *        As an additional spin, consider a return statement in a finally-block.
-     *        In this case, the value to return depends on how control arrived at that statement:
-     *        in case it arrived via a previous return, the previous return enjoys priority:
-     *        the value to return is given by that statement.
-     *
-     *    (b) A finally-block protects both the try-clause and the catch-clauses.
-     *
-     *           Sidenote:
-     *             A try-clause may contain an empty block. On CLR, a finally-block has special semantics
-     *             regarding Abort interruptions; but on the JVM it's safe to elide an exception-handler
-     *             that protects an "empty" range ("empty" as in "containing NOPs only",
-     *             see `asm.optimiz.DanglingExcHandlers` and SI-6720).
-     *
-     *        This means a finally-block indicates instructions that can be reached:
-     *          (b.1) Upon normal (non-early-returning) completion of the try-clause or a catch-clause
-     *                In this case, the next-program-point is that following the try-catch-finally expression.
-     *          (b.2) Upon early-return initiated in the try-clause or a catch-clause
-     *                In this case, the next-program-point is the enclosing cleanup section (if any), otherwise return.
-     *          (b.3) Upon abrupt termination (due to unhandled exception) of the try-clause or a catch-clause
-     *                In this case, the unhandled exception must be re-thrown after running the finally-block.
-     *
-     *    (c) finally-blocks are implicit to `synchronized` (a finally-block is added to just release the lock)
-     *        that's why `genSynchronized()` too emits cleanup-sections.
-     *
-     *  A number of code patterns can be emitted to realize the intended semantics.
-     *
-     *  A popular alternative (GenICode, javac) consists in duplicating the cleanup-chain at each early-return position.
-     *  The principle at work being that once control is transferred to a cleanup-section,
-     *  control will always stay within the cleanup-chain.
-     *  That is, barring an exception being thrown in a cleanup-section, in which case the enclosing try-block
-     *  (reached via abrupt termination) takes over.
-     *
-     *  The observations above hint at another code layout, less verbose, for the cleanup-chain.
-     *
-     *  The code layout that GenBCode emits takes into account that once a cleanup section has been reached,
-     *  jumping to the next cleanup-section (and so on, until the outermost one) realizes the correct semantics.
-     *
-     *  There is still code duplication in that two cleanup-chains are needed (but this is unavoidable, anyway):
-     *  one for normal control flow and another chain consisting of exception handlers.
-     *  The in-line comments below refer to them as
-     *    - "early-return-cleanups" and
-     *    - "exception-handler-version-of-finally-block" respectively.
-     *
-     */
-    def genLoadTry(tree: Try): BType = tree match {
-      case Try(block, catches, finalizer) =>
-      val kind = tpeTK(tree)
-
-      val caseHandlers: List[EHClause] =
-        for (CaseDef(pat, _, caseBody) <- catches) yield {
-          pat match {
-            case Typed(Ident(nme.WILDCARD), tpt)  => NamelessEH(tpeTK(tpt).asClassBType, caseBody)
-            case Ident(nme.WILDCARD)              => NamelessEH(jlThrowableRef,  caseBody)
-            case Bind(_, _)                       => BoundEH   (pat.symbol, caseBody)
-          }
-        }
-
-      // ------ (0) locals used later ------
-
-      /*
-       * `postHandlers` is a program point denoting:
-       *     (a) the finally-clause conceptually reached via fall-through from try-catch-finally
-       *         (in case a finally-block is present); or
-       *     (b) the program point right after the try-catch
-       *         (in case there's no finally-block).
-       * The name choice emphasizes that the code section lies "after all exception handlers",
-       * where "all exception handlers" includes those derived from catch-clauses as well as from finally-blocks.
-       */
-      val postHandlers = new asm.Label
-
-      val hasFinally   = (finalizer != tpd.EmptyTree)
-
-      /*
-       * used in the finally-clause reached via fall-through from try-catch, if any.
-       */
-      val guardResult  = hasFinally && (kind != UNIT) && mayCleanStack(finalizer)
-
-      /*
-       * please notice `tmp` has type tree.tpe, while `earlyReturnVar` has the method return type.
-       * Because those two types can be different, dedicated vars are needed.
-       */
-      val tmp          = if (guardResult) locals.makeLocal(tpeTK(tree), "tmp", tree.tpe, tree.span) else null
-
-      /*
-       * upon early return from the try-body or one of its EHs (but not the EH-version of the finally-clause)
-       * AND hasFinally, a cleanup is needed.
-       */
-      val finCleanup   = if (hasFinally) new asm.Label else null
-
-      /* ------ (1) try-block, protected by:
-       *                       (1.a) the EHs due to case-clauses,   emitted in (2),
-       *                       (1.b) the EH  due to finally-clause, emitted in (3.A)
-       *                       (1.c) whatever protects the whole try-catch-finally expression.
-       * ------
-       */
-
-      val startTryBody = currProgramPoint()
-      registerCleanup(finCleanup)
-      genLoad(block, kind)
-      unregisterCleanup(finCleanup)
-      nopIfNeeded(startTryBody)
-      val endTryBody = currProgramPoint()
-      bc goTo postHandlers
-
-      /**
-       * A return within a `try` or `catch` block where a `finally` is present ("early return")
-       * emits a store of the result to a local, jump to a "cleanup" version of the `finally` block,
-       * and sets `shouldEmitCleanup = true` (see [[PlainBodyBuilder.genReturn]]).
-       *
-       * If the try-catch is nested, outer `finally` blocks need to be emitted in a cleanup version
-       * as well, so the `shouldEmitCleanup` variable remains `true` until the outermost `finally`.
-       * Nested cleanup `finally` blocks jump to the next enclosing one. For the outermost, we emit
-       * a read of the local variable, a return, and we set `shouldEmitCleanup = false` (see
-       * [[pendingCleanups]]).
-       *
-       * Now, assume we have
-       *
-       *     try { return 1 } finally {
-       *       try { println() } finally { println() }
-       *     }
-       *
-       * Here, the outer `finally` needs a cleanup version, but the inner one does not. The method
-       * here makes sure that `shouldEmitCleanup` is only propagated outwards, not inwards to
-       * nested `finally` blocks.
-       */
-      def withFreshCleanupScope(body: => Unit) = {
-        val savedShouldEmitCleanup = shouldEmitCleanup
-        shouldEmitCleanup = false
-        body
-        shouldEmitCleanup = savedShouldEmitCleanup || shouldEmitCleanup
-      }
-
-      /* ------ (2) One EH for each case-clause (this does not include the EH-version of the finally-clause)
-       *            An EH in (2) is reached upon abrupt termination of (1).
-       *            An EH in (2) is protected by:
-       *                         (2.a) the EH-version of the finally-clause, if any.
-       *                         (2.b) whatever protects the whole try-catch-finally expression.
-       * ------
-       */
-
-      for (ch <- caseHandlers) withFreshCleanupScope {
-
-        // (2.a) emit case clause proper
-        val startHandler = currProgramPoint()
-        var endHandler: asm.Label = null
-        var excType: ClassBType = null
-        registerCleanup(finCleanup)
-        ch match {
-          case NamelessEH(typeToDrop, caseBody) =>
-            bc drop typeToDrop
-            genLoad(caseBody, kind) // adapts caseBody to `kind`, thus it can be stored, if `guardResult`, in `tmp`.
-            nopIfNeeded(startHandler)
-            endHandler = currProgramPoint()
-            excType = typeToDrop
-
-          case BoundEH   (patSymbol,  caseBody) =>
-            // test/files/run/contrib674.scala , a local-var already exists for patSymbol.
-            // rather than creating on first-access, we do it right away to emit debug-info for the created local var.
-            val Local(patTK, _, patIdx, _) = locals.getOrMakeLocal(patSymbol)
-            bc.store(patIdx, patTK)
-            genLoad(caseBody, kind)
-            nopIfNeeded(startHandler)
-            endHandler = currProgramPoint()
-            emitLocalVarScope(patSymbol, startHandler, endHandler)
-            excType = patTK.asClassBType
-        }
-        unregisterCleanup(finCleanup)
-        // (2.b)  mark the try-body as protected by this case clause.
-        protect(startTryBody, endTryBody, startHandler, excType)
-        // (2.c) emit jump to the program point where the finally-clause-for-normal-exit starts, or in effect `after` if no finally-clause was given.
-        bc goTo postHandlers
-
-      }
-
-      // Need to save the state of `shouldEmitCleanup` at this point: while emitting the first
-      // version of the `finally` block below, the variable may become true. But this does not mean
-      // that we need a cleanup version for the current block, only for the enclosing ones.
-      val currentFinallyBlockNeedsCleanup = shouldEmitCleanup
-
-      /* ------ (3.A) The exception-handler-version of the finally-clause.
-       *              Reached upon abrupt termination of (1) or one of the EHs in (2).
-       *              Protected only by whatever protects the whole try-catch-finally expression.
-       * ------
-       */
-
-      // a note on terminology: this is not "postHandlers", despite appearances.
-      // "postHandlers" as in the source-code view. And from that perspective, both (3.A) and (3.B) are invisible implementation artifacts.
-      if (hasFinally) withFreshCleanupScope {
-        nopIfNeeded(startTryBody)
-        val finalHandler = currProgramPoint() // version of the finally-clause reached via unhandled exception.
-        protect(startTryBody, finalHandler, finalHandler, null)
-        val Local(eTK, _, eIdx, _) = locals(locals.makeLocal(jlThrowableRef, "exc", defn.ThrowableType, finalizer.span))
-        bc.store(eIdx, eTK)
-        emitFinalizer(finalizer, null, isDuplicate = true)
-        bc.load(eIdx, eTK)
-        emit(asm.Opcodes.ATHROW)
-      }
-
-      /* ------ (3.B) Cleanup-version of the finally-clause.
-       *              Reached upon early RETURN from (1) or upon early RETURN from one of the EHs in (2)
-       *              (and only from there, ie reached only upon early RETURN from
-       *               program regions bracketed by registerCleanup/unregisterCleanup).
-       *              Protected only by whatever protects the whole try-catch-finally expression.
-       *
-       *              Given that control arrives to a cleanup section only upon early RETURN,
-       *              the value to return (if any) is always available. Therefore, a further RETURN
-       *              found in a cleanup section is always ignored (a warning is displayed, @see `genReturn()`).
-       *              In order for `genReturn()` to know whether the return statement is enclosed in a cleanup section,
-       *              the variable `insideCleanupBlock` is used.
-       * ------
-       */
-
-      // this is not "postHandlers" either.
-      // `shouldEmitCleanup` can be set, and at the same time this try expression may lack a finally-clause.
-      // In other words, all combinations of (hasFinally, shouldEmitCleanup) are valid.
-      if (hasFinally && currentFinallyBlockNeedsCleanup) {
-        markProgramPoint(finCleanup)
-        // regarding return value, the protocol is: in place of a `return-stmt`, a sequence of `adapt, store, jump` are inserted.
-        emitFinalizer(finalizer, null, isDuplicate = true)
-        pendingCleanups()
-      }
-
-      /* ------ (4) finally-clause-for-normal-nonEarlyReturn-exit
-       *            Reached upon normal, non-early-return termination of (1) or of an EH in (2).
-       *            Protected only by whatever protects the whole try-catch-finally expression.
-       * TODO explain what happens upon RETURN contained in (4)
-       * ------
-       */
-
-      markProgramPoint(postHandlers)
-      if (hasFinally) {
-        emitFinalizer(finalizer, tmp, isDuplicate = false) // the only invocation of emitFinalizer with `isDuplicate == false`
-      }
-
-      kind
-    } // end of genLoadTry()
-
-    /* if no more pending cleanups, all that remains to do is return. Otherwise jump to the next (outer) pending cleanup. */
-    private def pendingCleanups(): Unit = {
-      cleanups match {
-        case Nil =>
-          if (earlyReturnVar != null) {
-            locals.load(earlyReturnVar)
-            bc.emitRETURN(locals(earlyReturnVar).tk)
-          } else {
-            bc emitRETURN UNIT
-          }
-          shouldEmitCleanup = false
-
-        case nextCleanup :: _ =>
-          bc goTo nextCleanup
-      }
-    }
-
-    def protect(start: asm.Label, end: asm.Label, handler: asm.Label, excType: ClassBType): Unit = {
-      val excInternalName: String =
-        if (excType == null) null
-        else excType.internalName
-      assert(start != end, "protecting a range of zero instructions leads to illegal class format. Solution: add a NOP to that range.")
-      mnode.visitTryCatchBlock(start, end, handler, excInternalName)
-    }
-
-    /* `tmp` (if non-null) is the symbol of the local-var used to preserve the result of the try-body, see `guardResult` */
-    def emitFinalizer(finalizer: Tree, tmp: Symbol, isDuplicate: Boolean): Unit = {
-      var saved: immutable.Map[ /* Labeled */ Symbol, (BType, LoadDestination) ] = null
-      if (isDuplicate) {
-        saved = jumpDest
-      }
-      // when duplicating, the above guarantees new asm.Labels are used for LabelDefs contained in the finalizer (their vars are reused, that's ok)
-      if (tmp != null) { locals.store(tmp) }
-      genLoad(finalizer, UNIT)
-      if (tmp != null) { locals.load(tmp)  }
-      if (isDuplicate) {
-        jumpDest = saved
-      }
-    }
-
-    /* Does this tree have a try-catch block? */
-    def mayCleanStack(tree: Tree): Boolean = tree.find { t => t match { // TODO: use existsSubTree
-        case Try(_, _, _) => true
-        case _ => false
-      }
-    }.isDefined
-
-    trait EHClause
-    case class NamelessEH(typeToDrop: ClassBType,  caseBody: Tree) extends EHClause
-    case class BoundEH    (patSymbol: Symbol, caseBody: Tree) extends EHClause
-
-  }
-
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/BTypes.scala b/tests/pos-with-compiler-cc/backend/jvm/BTypes.scala
deleted file mode 100644
index f9a3a3aae105..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/BTypes.scala
+++ /dev/null
@@ -1,864 +0,0 @@
-package dotty.tools
-package backend
-package jvm
-
-import scala.language.unsafeNulls
-
-import scala.tools.asm
-
-/**
- * The BTypes component defines The BType class hierarchy. BTypes encapsulates all type information
- * that is required after building the ASM nodes. This includes optimizations, geneartion of
- * InnerClass attributes and generation of stack map frames.
- *
- * This representation is immutable and independent of the compiler data structures, hence it can
- * be queried by concurrent threads.
- */
-abstract class BTypes extends Pure {
-
-  val int: DottyBackendInterface
-  import int.given
-  /**
-   * A map from internal names to ClassBTypes. Every ClassBType is added to this map on its
-   * construction.
-   *
-   * This map is used when computing stack map frames. The asm.ClassWriter invokes the method
-   * `getCommonSuperClass`. In this method we need to obtain the ClassBType for a given internal
-   * name. The method assumes that every class type that appears in the bytecode exists in the map.
-   *
-   * Concurrent because stack map frames are computed when in the class writer, which might run
-   * on multiple classes concurrently.
-   */
-  protected def classBTypeFromInternalNameMap: collection.concurrent.Map[String, ClassBType]
-    // NOTE: Should be a lazy val but scalac does not allow abstract lazy vals (dotty does)
-
-  /**
-   * Obtain a previously constructed ClassBType for a given internal name.
-   */
-  def classBTypeFromInternalName(internalName: String) = classBTypeFromInternalNameMap(internalName)
-
-  // Some core BTypes are required here, in class BType, where no Global instance is available.
-  // The Global is only available in the subclass BTypesFromSymbols. We cannot depend on the actual
-  // implementation (CoreBTypesProxy) here because it has members that refer to global.Symbol.
-  val coreBTypes: CoreBTypesProxyGlobalIndependent[this.type]
-  import coreBTypes._
-
-  /**
-   * A BType is either a primitve type, a ClassBType, an ArrayBType of one of these, or a MethodType
-   * referring to BTypes.
-   */
-  /*sealed*/ trait BType extends Pure { // Not sealed for now due to SI-8546
-    final override def toString: String = this match {
-      case UNIT   => "V"
-      case BOOL   => "Z"
-      case CHAR   => "C"
-      case BYTE   => "B"
-      case SHORT  => "S"
-      case INT    => "I"
-      case FLOAT  => "F"
-      case LONG   => "J"
-      case DOUBLE => "D"
-      case ClassBType(internalName) => "L" + internalName + ";"
-      case ArrayBType(component)    => "[" + component
-      case MethodBType(args, res)   => args.mkString("(", "", ")" + res)
-    }
-
-    /**
-     * @return The Java descriptor of this type. Examples:
-     *  - int: I
-     *  - java.lang.String: Ljava/lang/String;
-     *  - int[]: [I
-     *  - Object m(String s, double d): (Ljava/lang/String;D)Ljava/lang/Object;
-     */
-    final def descriptor = toString
-
-    /**
-     * @return 0 for void, 2 for long and double, 1 otherwise
-     */
-    final def size: Int = this match {
-      case UNIT => 0
-      case LONG | DOUBLE => 2
-      case _ => 1
-    }
-
-    final def isPrimitive: Boolean = this.isInstanceOf[PrimitiveBType]
-    final def isRef: Boolean       = this.isInstanceOf[RefBType]
-    final def isArray: Boolean     = this.isInstanceOf[ArrayBType]
-    final def isClass: Boolean     = this.isInstanceOf[ClassBType]
-    final def isMethod: Boolean    = this.isInstanceOf[MethodBType]
-
-    final def isNonVoidPrimitiveType = isPrimitive && this != UNIT
-
-    final def isNullType             = this == srNullRef
-    final def isNothingType          = this == srNothingRef
-
-    final def isBoxed = this.isClass && boxedClasses(this.asClassBType)
-
-    final def isIntSizedType = this == BOOL || this == CHAR || this == BYTE ||
-                               this == SHORT || this == INT
-    final def isIntegralType = this == INT || this == BYTE || this == LONG ||
-                               this == CHAR || this == SHORT
-    final def isRealType     = this == FLOAT || this == DOUBLE
-    final def isNumericType  = isIntegralType || isRealType
-    final def isWideType     = size == 2
-
-    /*
-     * Subtype check `this <:< other` on BTypes that takes into account the JVM built-in numeric
-     * promotions (e.g. BYTE to INT). Its operation can be visualized more easily in terms of the
-     * Java bytecode type hierarchy.
-     */
-    final def conformsTo(other: BType): Boolean = {
-      assert(isRef || isPrimitive, s"conformsTo cannot handle $this")
-      assert(other.isRef || other.isPrimitive, s"conformsTo cannot handle $other")
-
-      this match {
-        case ArrayBType(component) =>
-          if (other == ObjectRef || other == jlCloneableRef || other == jiSerializableRef) true
-          else other match {
-            case ArrayBType(otherComponoent) => component.conformsTo(otherComponoent)
-            case _ => false
-          }
-
-        case classType: ClassBType =>
-          if (isBoxed) {
-            if (other.isBoxed) this == other
-            else if (other == ObjectRef) true
-            else other match {
-              case otherClassType: ClassBType => classType.isSubtypeOf(otherClassType) // e.g., java/lang/Double conforms to java/lang/Number
-              case _ => false
-            }
-          } else if (isNullType) {
-            if (other.isNothingType) false
-            else if (other.isPrimitive) false
-            else true // Null conforms to all classes (except Nothing) and arrays.
-          } else if (isNothingType) {
-            true
-          } else other match {
-            case otherClassType: ClassBType => classType.isSubtypeOf(otherClassType)
-            // case ArrayBType(_) => this.isNullType   // documentation only, because `if (isNullType)` above covers this case
-            case _ =>
-              // isNothingType ||                      // documentation only, because `if (isNothingType)` above covers this case
-              false
-          }
-
-        case UNIT =>
-          other == UNIT
-        case BOOL | BYTE | SHORT | CHAR =>
-          this == other || other == INT || other == LONG // TODO Actually, BOOL does NOT conform to LONG. Even with adapt().
-        case _ =>
-          assert(isPrimitive && other.isPrimitive, s"Expected primitive types $this - $other")
-          this == other
-      }
-    }
-
-    /**
-     * Compute the upper bound of two types.
-     * Takes promotions of numeric primitives into account.
-     */
-    final def maxType(other: BType): BType = this match {
-      case pt: PrimitiveBType => pt.maxValueType(other)
-
-      case _: ArrayBType | _: ClassBType =>
-        if (isNothingType)       return other
-        if (other.isNothingType) return this
-        if (this == other)       return this
-
-        assert(other.isRef, s"Cannot compute maxType: $this, $other")
-        // Approximate `lub`. The common type of two references is always ObjectReference.
-        ObjectRef
-    }
-
-    /**
-     * See documentation of [[typedOpcode]].
-     * The numbers are taken from asm.Type.VOID_TYPE ff., the values are those shifted by << 8.
-     */
-    private def loadStoreOpcodeOffset: Int = this match {
-      case UNIT | INT  => 0
-      case BOOL | BYTE => 5
-      case CHAR        => 6
-      case SHORT       => 7
-      case FLOAT       => 2
-      case LONG        => 1
-      case DOUBLE      => 3
-      case _           => 4
-    }
-
-    /**
-     * See documentation of [[typedOpcode]].
-     * The numbers are taken from asm.Type.VOID_TYPE ff., the values are those shifted by << 16.
-     */
-    private def typedOpcodeOffset: Int = this match {
-      case UNIT                               => 5
-      case BOOL | CHAR | BYTE | SHORT | INT   => 0
-      case FLOAT                              => 2
-      case LONG                               => 1
-      case DOUBLE                             => 3
-      case _                                  => 4
-    }
-
-    /**
-     * Some JVM opcodes have typed variants. This method returns the correct opcode according to
-     * the type.
-     *
-     * @param opcode A JVM instruction opcode. This opcode must be one of ILOAD, ISTORE, IALOAD,
-     *               IASTORE, IADD, ISUB, IMUL, IDIV, IREM, INEG, ISHL, ISHR, IUSHR, IAND, IOR
-     *               IXOR and IRETURN.
-     * @return The opcode adapted to this java type. For example, if this type is `float` and
-     *         `opcode` is `IRETURN`, this method returns `FRETURN`.
-     */
-    final def typedOpcode(opcode: Int): Int = {
-      if (opcode == asm.Opcodes.IALOAD || opcode == asm.Opcodes.IASTORE)
-        opcode + loadStoreOpcodeOffset
-      else
-        opcode + typedOpcodeOffset
-    }
-
-    /**
-     * The asm.Type corresponding to this BType.
-     *
-     * Note about asm.Type.getObjectType (*): For class types, the method expects the internal
-     * name, i.e. without the surrounding 'L' and ';'. For array types on the other hand, the
-     * method expects a full descriptor, for example "[Ljava/lang/String;".
-     *
-     * See method asm.Type.getType that creates a asm.Type from a type descriptor
-     *  - for an OBJECT type, the 'L' and ';' are not part of the range of the created Type
-     *  - for an ARRAY type, the full descriptor is part of the range
-     */
-    def toASMType: asm.Type = this match {
-      case UNIT   => asm.Type.VOID_TYPE
-      case BOOL   => asm.Type.BOOLEAN_TYPE
-      case CHAR   => asm.Type.CHAR_TYPE
-      case BYTE   => asm.Type.BYTE_TYPE
-      case SHORT  => asm.Type.SHORT_TYPE
-      case INT    => asm.Type.INT_TYPE
-      case FLOAT  => asm.Type.FLOAT_TYPE
-      case LONG   => asm.Type.LONG_TYPE
-      case DOUBLE => asm.Type.DOUBLE_TYPE
-      case ClassBType(internalName) => asm.Type.getObjectType(internalName) // see (*) above
-      case a: ArrayBType            => asm.Type.getObjectType(a.descriptor)
-      case m: MethodBType           => asm.Type.getMethodType(m.descriptor)
-    }
-
-    def asRefBType       : RefBType       = this.asInstanceOf[RefBType]
-    def asArrayBType     : ArrayBType     = this.asInstanceOf[ArrayBType]
-    def asClassBType     : ClassBType     = this.asInstanceOf[ClassBType]
-    def asPrimitiveBType : PrimitiveBType = this.asInstanceOf[PrimitiveBType]
-  }
-
-  sealed trait PrimitiveBType extends BType {
-
-    /**
-     * The upper bound of two primitive types. The `other` type has to be either a primitive
-     * type or Nothing.
-     *
-     * The maxValueType of (Char, Byte) and of (Char, Short) is Int, to encompass the negative
-     * values of Byte and Short. See ticket #2087.
-     */
-    final def maxValueType(other: BType): BType = {
-
-      def uncomparable: Nothing = throw new AssertionError(s"Cannot compute maxValueType: $this, $other")
-
-      if (!other.isPrimitive && !other.isNothingType) uncomparable
-
-      if (other.isNothingType) return this
-      if (this == other)       return this
-
-      this match {
-        case BYTE =>
-          if (other == CHAR)            INT
-          else if (other.isNumericType) other
-          else                          uncomparable
-
-        case SHORT =>
-          other match {
-            case BYTE                          => SHORT
-            case CHAR                          => INT
-            case INT  | LONG  | FLOAT | DOUBLE => other
-            case _                             => uncomparable
-          }
-
-        case CHAR =>
-          other match {
-            case BYTE | SHORT                 => INT
-            case INT  | LONG | FLOAT | DOUBLE => other
-            case _                            => uncomparable
-          }
-
-        case INT =>
-          other match {
-            case BYTE | SHORT | CHAR   => INT
-            case LONG | FLOAT | DOUBLE => other
-            case _                     => uncomparable
-          }
-
-        case LONG =>
-          other match {
-            case INT | BYTE | LONG | CHAR | SHORT => LONG
-            case DOUBLE                           => DOUBLE
-            case FLOAT                            => FLOAT
-            case _                                => uncomparable
-          }
-
-        case FLOAT =>
-          if (other == DOUBLE)          DOUBLE
-          else if (other.isNumericType) FLOAT
-          else                          uncomparable
-
-        case DOUBLE =>
-          if (other.isNumericType) DOUBLE
-          else                     uncomparable
-
-        case UNIT | BOOL => uncomparable
-      }
-    }
-  }
-
-  case object UNIT   extends PrimitiveBType
-  case object BOOL   extends PrimitiveBType
-  case object CHAR   extends PrimitiveBType
-  case object BYTE   extends PrimitiveBType
-  case object SHORT  extends PrimitiveBType
-  case object INT    extends PrimitiveBType
-  case object FLOAT  extends PrimitiveBType
-  case object LONG   extends PrimitiveBType
-  case object DOUBLE extends PrimitiveBType
-
-  sealed trait RefBType extends BType {
-    /**
-     * The class or array type of this reference type. Used for ANEWARRAY, MULTIANEWARRAY,
-     * INSTANCEOF and CHECKCAST instructions. Also used for emitting invokevirtual calls to
-     * (a: Array[T]).clone() for any T, see genApply.
-     *
-     * In contrast to the descriptor, this string does not contain the surrounding 'L' and ';' for
-     * class types, for example "java/lang/String".
-     * However, for array types, the full descriptor is used, for example "[Ljava/lang/String;".
-     *
-     * This can be verified for example using javap or ASMifier.
-     */
-    def classOrArrayType: String = this match {
-      case ClassBType(internalName) => internalName
-      case a: ArrayBType            => a.descriptor
-    }
-  }
-
-  /**
-   * InnerClass and EnclosingMethod attributes (EnclosingMethod is displayed as OUTERCLASS in asm).
-   *
-   * In this summary, "class" means "class or interface".
-   *
-   * JLS: http://docs.oracle.com/javase/specs/jls/se8/html/index.html
-   * JVMS: http://docs.oracle.com/javase/specs/jvms/se8/html/index.html
-   *
-   * Terminology
-   * -----------
-   *
-   *  - Nested class (JLS 8): class whose declaration occurs within the body of another class
-   *
-   *  - Top-level class (JLS 8): non-nested class
-   *
-   *  - Inner class (JLS 8.1.3): nested class that is not (explicitly or implicitly) static
-   *
-   *  - Member class (JLS 8.5): class directly enclosed in the body of a class (and not, for
-   *    example, defined in a method). Member classes cannot be anonymous. May be static.
-   *
-   *  - Local class (JLS 14.3): nested, non-anonymous class that is not a member of a class
-   *    - cannot be static (therefore they are "inner" classes)
-   *    - can be defined in a method, a constructor or in an initializer block
-   *
-   *  - Initializer block (JLS 8.6 / 8.7): block of statements in a java class
-   *    - static initializer: executed before constructor body
-   *    - instance initializer: executed when class is initialized (instance creation, static
-   *      field access, ...)
-   *
-   *  - A static nested class can be defined as
-   *    - a static member class (explicitly static), or
-   *    - a member class of an interface (implicitly static)
-   *    - local classes are never static, even if they are defined in a static method.
-   *
-   *   Note: it is NOT the case that all inner classes (non-static) have an outer pointer. Example:
-   *     class C { static void foo { class D {} } }
-   *   The class D is an inner class (non-static), but javac does not add an outer pointer to it.
-   *
-   * InnerClass
-   * ----------
-   *
-   * The JVMS 4.7.6 requires an entry for every class mentioned in a CONSTANT_Class_info in the
-   * constant pool (CP) that is not a member of a package (JLS 7.1).
-   *
-   * The JLS 13.1, points 9. / 10. requires: a class must reference (in the CP)
-   *  - its immediately enclosing class
-   *  - all of its member classes
-   *  - all local and anonymous classes that are referenced (or declared) elsewhere (method,
-   *    constructor, initializer block, field initializer)
-   *
-   * In a comment, the 4.7.6 spec says: this implies an entry in the InnerClass attribute for
-   *  - All enclosing classes (except the outermost, which is top-level)
-   *    - My comment: not sure how this is implied, below (*) a Java counter-example.
-   *      In any case, the Java compiler seems to add all enclosing classes, even if they are not
-   *      otherwise mentioned in the CP. So we should do the same.
-   *  - All nested classes (including anonymous and local, but not transitively)
-   *
-   * Fields in the InnerClass entries:
-   *  - inner class: the (nested) class C we are talking about
-   *  - outer class: the class of which C is a member. Has to be null for non-members, i.e. for
-   *                 local and anonymous classes. NOTE: this co-incides with the presence of an
-   *                 EnclosingMethod attribute (see below)
-   *  - inner name:  A string with the simple name of the inner class. Null for anonymous classes.
-   *  - flags:       access property flags, details in JVMS, table in 4.7.6. Static flag: see
-   *                 discussion below.
-   *
-   *
-   * Note 1: when a nested class is present in the InnerClass attribute, all of its enclosing
-   * classes have to be present as well (by the rules above). Example:
-   *
-   *   class Outer { class I1 { class I2 { } } }
-   *   class User { Outer.I1.I2 foo() { } }
-   *
-   * The return type "Outer.I1.I2" puts "Outer$I1$I2" in the CP, therefore the class is added to the
-   * InnerClass attribute. For this entry, the "outer class" field will be "Outer$I1". This in turn
-   * adds "Outer$I1" to the CP, which requires adding that class to the InnerClass attribute.
-   * (For local / anonymous classes this would not be the case, since the "outer class" attribute
-   *  would be empty. However, no class (other than the enclosing class) can refer to them, as they
-   *  have no name.)
-   *
-   * In the current implementation of the Scala compiler, when adding a class to the InnerClass
-   * attribute, all of its enclosing classes will be added as well. Javac seems to do the same,
-   * see (*).
-   *
-   *
-   * Note 2: If a class name is mentioned only in a CONSTANT_Utf8_info, but not in a
-   * CONSTANT_Class_info, the JVMS does not require an entry in the InnerClass attribute. However,
-   * the Java compiler seems to add such classes anyway. For example, when using an annotation, the
-   * annotation class is stored as a CONSTANT_Utf8_info in the CP:
-   *
-   *   @O.Ann void foo() { }
-   *
-   * adds "const #13 = Asciz LO$Ann;;" in the constant pool. The "RuntimeInvisibleAnnotations"
-   * attribute refers to that constant pool entry. Even though there is no other reference to
-   * `O.Ann`, the java compiler adds an entry for that class to the InnerClass attribute (which
-   * entails adding a CONSTANT_Class_info for the class).
-   *
-   *
-   *
-   * EnclosingMethod
-   * ---------------
-   *
-   * JVMS 4.7.7: the attribute must be present "if and only if it represents a local class
-   * or an anonymous class" (i.e. not for member classes).
-   *
-   * The attribute is mis-named, it should be called "EnclosingClass". It has to be defined for all
-   * local and anonymous classes, no matter if there is an enclosing method or not. Accordingly, the
-   * "class" field (see below) must be always defined, while the "method" field may be null.
-   *
-   * NOTE: When a EnclosingMethod attribute is required (local and anonymous classes), the "outer"
-   * field in the InnerClass table must be null.
-   *
-   * Fields:
-   *  - class:  the enclosing class
-   *  - method: the enclosing method (or constructor). Null if the class is not enclosed by a
-   *            method, i.e. for
-   *             - local or anonymous classes defined in (static or non-static) initializer blocks
-   *             - anonymous classes defined in initializer blocks or field initializers
-   *
-   *            Note: the field is required for anonymous classes defined within local variable
-   *            initializers (within a method), Java example below (**).
-   *
-   *            For local and anonymous classes in initializer blocks or field initializers, and
-   *            class-level anonymous classes, the scala compiler sets the "method" field to null.
-   *
-   *
-   * (*)
-   *   public class Test {
-   *     void foo() {
-   *       class Foo1 {
-   *         // constructor statement block
-   *         {
-   *           class Foo2 {
-   *             class Foo3 { }
-   *           }
-   *         }
-   *       }
-   *     }
-   *   }
-   *
-   * The class file Test$1Foo1$1Foo2$Foo3 has no reference to the class Test$1Foo1, however it
-   * still contains an InnerClass attribute for Test$1Foo1.
-   * Maybe this is just because the Java compiler follows the JVMS comment ("InnerClasses
-   * information for each enclosing class").
-   *
-   *
-   * (**)
-   *   void foo() {
-   *     // anonymous class defined in local variable initializer expression.
-   *     Runnable x = true ? (new Runnable() {
-   *       public void run() { return; }
-   *     }) : null;
-   *   }
-   *
-   * The EnclosingMethod attribute of the anonymous class mentions "foo" in the "method" field.
-   *
-   *
-   * Java Compatibility
-   * ------------------
-   *
-   * In the InnerClass entry for classes in top-level modules, the "outer class" is emitted as the
-   * mirror class (or the existing companion class), i.e. C1 is nested in T (not T$).
-   * For classes nested in a nested object, the "outer class" is the module class: C2 is nested in T$N$
-   * object T {
-   *   class C1
-   *   object N { class C2 }
-   * }
-   *
-   * Reason: java compat. It's a "best effort" "solution". If you want to use "C1" from Java, you
-   * can write "T.C1", and the Java compiler will translate that to the classfile T$C1.
-   *
-   * If we would emit the "outer class" of C1 as "T$", then in Java you'd need to write "T$.C1"
-   * because the java compiler looks at the InnerClass attribute to find if an inner class exists.
-   * However, the Java compiler would then translate the '.' to '$' and you'd get the class name
-   * "T$$C1". This class file obviously does not exist.
-   *
-   * Directly using the encoded class name "T$C1" in Java does not work: since the classfile
-   * describes a nested class, the Java compiler hides it from the classpath and will report
-   * "cannot find symbol T$C1". This means that the class T.N.C2 cannot be referenced from a
-   * Java source file in any way.
-   *
-   *
-   * STATIC flag
-   * -----------
-   *
-   * Java: static member classes have the static flag in the InnerClass attribute, for example B in
-   *   class A { static class B { } }
-   *
-   * The spec is not very clear about when the static flag should be emitted. It says: "Marked or
-   * implicitly static in source."
-   *
-   * The presence of the static flag does NOT coincide with the absence of an "outer" field in the
-   * class. The java compiler never puts the static flag for local classes, even if they don't have
-   * an outer pointer:
-   *
-   *   class A {
-   *     void f()        { class B {} }
-   *     static void g() { calss C {} }
-   *   }
-   *
-   * B has an outer pointer, C doesn't. Both B and C are NOT marked static in the InnerClass table.
-   *
-   * It seems sane to follow the same principle in the Scala compiler. So:
-   *
-   *   package p
-   *   object O1 {
-   *     class C1 // static inner class
-   *     object O2 { // static inner module
-   *       def f = {
-   *         class C2 { // non-static inner class, even though there's no outer pointer
-   *           class C3 // non-static, has an outer pointer
-   *         }
-   *       }
-   *     }
-   *   }
-   *
-   * Mirror Classes
-   * --------------
-   *
-   * TODO: innerclass attributes on mirror class
-   */
-
-  /**
-   * A ClassBType represents a class or interface type. The necessary information to build a
-   * ClassBType is extracted from compiler symbols and types, see BTypesFromSymbols.
-   *
-   * The `offset` and `length` fields are used to represent the internal name of the class. They
-   * are indices into some character array. The internal name can be obtained through the method
-   * `internalNameString`, which is abstract in this component. Name creation is assumed to be
-   * hash-consed, so if two ClassBTypes have the same internal name, they NEED to have the same
-   * `offset` and `length`.
-   *
-   * The actual implementation in subclass BTypesFromSymbols uses the global `chrs` array from the
-   * name table. This representation is efficient because the JVM class name is obtained through
-   * `classSymbol.javaBinaryName`. This already adds the necessary string to the `chrs` array,
-   * so it makes sense to reuse the same name table in the backend.
-   *
-   * ClassBType is not a case class because we want a custom equals method, and because the
-   * extractor extracts the internalName, which is what you typically need.
-   */
-  final class ClassBType(val internalName: String) extends RefBType {
-    /**
-     * Write-once variable allows initializing a cyclic graph of infos. This is required for
-     * nested classes. Example: for the definition `class A { class B }` we have
-     *
-     *   B.info.nestedInfo.outerClass == A
-     *   A.info.memberClasses contains B
-     */
-    private var _info: ClassInfo = null
-
-    def info: ClassInfo = {
-      assert(_info != null, s"ClassBType.info not yet assigned: $this")
-      _info
-    }
-
-    def info_=(i: ClassInfo): Unit = {
-      assert(_info == null, s"Cannot set ClassBType.info multiple times: $this")
-      _info = i
-      checkInfoConsistency()
-    }
-
-    classBTypeFromInternalNameMap(internalName) = this
-
-    private def checkInfoConsistency(): Unit = {
-      // we assert some properties. however, some of the linked ClassBType (members, superClass,
-      // interfaces) may not yet have an `_info` (initialization of cyclic structures). so we do a
-      // best-effort verification.
-      def ifInit(c: ClassBType)(p: ClassBType => Boolean): Boolean = c._info == null || p(c)
-
-      def isJLO(t: ClassBType) = t.internalName == "java/lang/Object"
-
-      assert(!ClassBType.isInternalPhantomType(internalName), s"Cannot create ClassBType for phantom type $this")
-
-      assert(
-        if (info.superClass.isEmpty) { isJLO(this) || (DottyBackendInterface.isCompilingPrimitive && ClassBType.hasNoSuper(internalName)) }
-        else if (isInterface) isJLO(info.superClass.get)
-        else !isJLO(this) && ifInit(info.superClass.get)(!_.isInterface),
-        s"Invalid superClass in $this: ${info.superClass}"
-      )
-      assert(
-        info.interfaces.forall(c => ifInit(c)(_.isInterface)),
-        s"Invalid interfaces in $this: ${info.interfaces}"
-      )
-
-      assert(info.memberClasses.forall(c => ifInit(c)(_.isNestedClass)), info.memberClasses)
-    }
-
-    /**
-     * The internal name of a class is the string returned by java.lang.Class.getName, with all '.'
-     * replaced by '/'. For example "java/lang/String".
-     */
-    //def internalName: String = internalNameString(offset, length)
-
-    /**
-     * @return The class name without the package prefix
-     */
-    def simpleName: String = internalName.split("/").last
-
-    def isInterface = (info.flags & asm.Opcodes.ACC_INTERFACE) != 0
-
-    def superClassesTransitive: List[ClassBType] = info.superClass match {
-      case None => Nil
-      case Some(sc) => sc :: sc.superClassesTransitive
-    }
-
-    def isNestedClass = info.nestedInfo.isDefined
-
-    def enclosingNestedClassesChain: List[ClassBType] =
-      if (isNestedClass) this :: info.nestedInfo.get.enclosingClass.enclosingNestedClassesChain
-      else Nil
-
-    def innerClassAttributeEntry: Option[InnerClassEntry] = info.nestedInfo map {
-      case NestedInfo(_, outerName, innerName, isStaticNestedClass) =>
-        import GenBCodeOps.addFlagIf
-        InnerClassEntry(
-          internalName,
-          outerName.orNull,
-          innerName.orNull,
-          info.flags.addFlagIf(isStaticNestedClass, asm.Opcodes.ACC_STATIC)
-            & ClassBType.INNER_CLASSES_FLAGS
-        )
-    }
-
-    def isSubtypeOf(other: ClassBType): Boolean = {
-      if (this == other) return true
-
-      if (isInterface) {
-        if (other == ObjectRef) return true // interfaces conform to Object
-        if (!other.isInterface) return false // this is an interface, the other is some class other than object. interfaces cannot extend classes, so the result is false.
-        // else: this and other are both interfaces. continue to (*)
-      } else {
-        val sc = info.superClass
-        if (sc.isDefined && sc.get.isSubtypeOf(other)) return true // the superclass of this class conforms to other
-        if (!other.isInterface) return false // this and other are both classes, and the superclass of this does not conform
-        // else: this is a class, the other is an interface. continue to (*)
-      }
-
-      // (*) check if some interface of this class conforms to other.
-      info.interfaces.exists(_.isSubtypeOf(other))
-    }
-
-    /**
-     * Finding the least upper bound in agreement with the bytecode verifier
-     * Background:
-     *   http://gallium.inria.fr/~xleroy/publi/bytecode-verification-JAR.pdf
-     *   http://comments.gmane.org/gmane.comp.java.vm.languages/2293
-     *   https://issues.scala-lang.org/browse/SI-3872
-     */
-    def jvmWiseLUB(other: ClassBType): ClassBType = {
-      def isNotNullOrNothing(c: ClassBType) = !c.isNullType && !c.isNothingType
-      assert(isNotNullOrNothing(this) && isNotNullOrNothing(other), s"jvmWiseLub for null or nothing: $this - $other")
-
-      val res: ClassBType = (this.isInterface, other.isInterface) match {
-        case (true, true) =>
-          // exercised by test/files/run/t4761.scala
-          if      (other.isSubtypeOf(this)) this
-          else if (this.isSubtypeOf(other)) other
-          else ObjectRef
-
-        case (true, false) =>
-          if (other.isSubtypeOf(this)) this else ObjectRef
-
-        case (false, true) =>
-          if (this.isSubtypeOf(other)) other else ObjectRef
-
-        case _ =>
-          // TODO @lry I don't really understand the reasoning here.
-          // Both this and other are classes. The code takes (transitively) all superclasses and
-          // finds the first common one.
-          // MOST LIKELY the answer can be found here, see the comments and links by Miguel:
-          //  - https://issues.scala-lang.org/browse/SI-3872
-          firstCommonSuffix(this :: this.superClassesTransitive, other :: other.superClassesTransitive)
-      }
-
-      assert(isNotNullOrNothing(res), s"jvmWiseLub computed: $res")
-      res
-    }
-
-    private def firstCommonSuffix(as: List[ClassBType], bs: List[ClassBType]): ClassBType = {
-      var chainA = as
-      var chainB = bs
-      var fcs: ClassBType = null
-      while {
-        if      (chainB contains chainA.head) fcs = chainA.head
-        else if (chainA contains chainB.head) fcs = chainB.head
-        else {
-          chainA = chainA.tail
-          chainB = chainB.tail
-        }
-        fcs == null
-      } do ()
-      fcs
-    }
-
-    /**
-     * Custom equals / hashCode: we only compare the name (offset / length)
-     */
-    override def equals(o: Any): Boolean = (this eq o.asInstanceOf[Object]) || (o match {
-      case c: ClassBType @unchecked => c.internalName == this.internalName
-      case _ => false
-    })
-
-    override def hashCode: Int = {
-      import scala.runtime.Statics
-      var acc: Int = -889275714
-      acc = Statics.mix(acc, internalName.hashCode)
-      Statics.finalizeHash(acc, 2)
-    }
-  }
-
-  object ClassBType {
-    /**
-     * Pattern matching on a ClassBType extracts the `internalName` of the class.
-     */
-    def unapply(c: ClassBType): Some[String] = Some(c.internalName)
-
-    /**
-     * Valid flags for InnerClass attribute entry.
-     * See http://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.6
-     */
-    private val INNER_CLASSES_FLAGS = {
-      asm.Opcodes.ACC_PUBLIC   | asm.Opcodes.ACC_PRIVATE   | asm.Opcodes.ACC_PROTECTED  |
-      asm.Opcodes.ACC_STATIC   | asm.Opcodes.ACC_FINAL     | asm.Opcodes.ACC_INTERFACE  |
-      asm.Opcodes.ACC_ABSTRACT | asm.Opcodes.ACC_SYNTHETIC | asm.Opcodes.ACC_ANNOTATION |
-      asm.Opcodes.ACC_ENUM
-    }
-
-    // Primitive classes have no super class. A ClassBType for those is only created when
-    // they are actually being compiled (e.g., when compiling scala/Boolean.scala).
-    private val hasNoSuper = Set(
-      "scala/Unit",
-      "scala/Boolean",
-      "scala/Char",
-      "scala/Byte",
-      "scala/Short",
-      "scala/Int",
-      "scala/Float",
-      "scala/Long",
-      "scala/Double"
-    )
-
-    private val isInternalPhantomType = Set(
-      "scala/Null",
-      "scala/Nothing"
-    )
-  }
-
-  /**
-   * The type info for a class. Used for symboltable-independent subtype checks in the backend.
-   *
-   * @param superClass    The super class, not defined for class java/lang/Object.
-   * @param interfaces    All transitively implemented interfaces, except for those inherited
-   *                      through the superclass.
-   * @param flags         The java flags, obtained through `javaFlags`. Used also to derive
-   *                      the flags for InnerClass entries.
-   * @param memberClasses Classes nested in this class. Those need to be added to the
-   *                      InnerClass table, see the InnerClass spec summary above.
-   * @param nestedInfo    If this describes a nested class, information for the InnerClass table.
-   */
-  case class ClassInfo(superClass: Option[ClassBType], interfaces: List[ClassBType], flags: Int,
-                       memberClasses: List[ClassBType], nestedInfo: Option[NestedInfo])
-
-  /**
-   * Information required to add a class to an InnerClass table.
-   * The spec summary above explains what information is required for the InnerClass entry.
-   *
-   * @param enclosingClass      The enclosing class, if it is also nested. When adding a class
-   *                            to the InnerClass table, enclosing nested classes are also added.
-   * @param outerName           The outerName field in the InnerClass entry, may be None.
-   * @param innerName           The innerName field, may be None.
-   * @param isStaticNestedClass True if this is a static nested class (not inner class) (*)
-   *
-   * (*) Note that the STATIC flag in ClassInfo.flags, obtained through javaFlags(classSym), is not
-   * correct for the InnerClass entry, see javaFlags. The static flag in the InnerClass describes
-   * a source-level propety: if the class is in a static context (does not have an outer pointer).
-   * This is checked when building the NestedInfo.
-   */
-  case class NestedInfo(enclosingClass: ClassBType,
-                        outerName: Option[String],
-                        innerName: Option[String],
-                        isStaticNestedClass: Boolean)
-
-  /**
-   * This class holds the data for an entry in the InnerClass table. See the InnerClass summary
-   * above in this file.
-   *
-   * There's some overlap with the class NestedInfo, but it's not exactly the same and cleaner to
-   * keep separate.
-   * @param name      The internal name of the class.
-   * @param outerName The internal name of the outer class, may be null.
-   * @param innerName The simple name of the inner class, may be null.
-   * @param flags     The flags for this class in the InnerClass entry.
-   */
-  case class InnerClassEntry(name: String, outerName: String, innerName: String, flags: Int)
-
-  case class ArrayBType(componentType: BType) extends RefBType {
-    def dimension: Int = componentType match {
-      case a: ArrayBType => 1 + a.dimension
-      case _ => 1
-    }
-
-    def elementType: BType = componentType match {
-      case a: ArrayBType => a.elementType
-      case t => t
-    }
-  }
-
-  case class MethodBType(argumentTypes: List[BType], returnType: BType) extends BType
-
-  /* Some definitions that are required for the implementation of BTypes. They are abstract because
-   * initializing them requires information from types / symbols, which is not accessible here in
-   * BTypes.
-   *
-   * They are defs (not vals) because they are implemented using vars (see comment on CoreBTypes).
-   */
-
-  /**
-   * Just a named pair, used in CoreBTypes.asmBoxTo/asmUnboxTo.
-   */
-  /*final*/ case class MethodNameAndType(name: String, methodType: MethodBType)
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/BTypesFromSymbols.scala b/tests/pos-with-compiler-cc/backend/jvm/BTypesFromSymbols.scala
deleted file mode 100644
index d78008d65cc6..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/BTypesFromSymbols.scala
+++ /dev/null
@@ -1,348 +0,0 @@
-package dotty.tools
-package backend
-package jvm
-
-import scala.tools.asm
-import scala.annotation.threadUnsafe
-import scala.collection.mutable
-import scala.collection.mutable.Clearable
-
-import dotty.tools.dotc.core.Flags._
-import dotty.tools.dotc.core.Contexts._
-import dotty.tools.dotc.core.Phases._
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.core.Phases.Phase
-import dotty.tools.dotc.transform.SymUtils._
-import dotty.tools.dotc.core.StdNames
-
-/**
- * This class mainly contains the method classBTypeFromSymbol, which extracts the necessary
- * information from a symbol and its type to create the corresponding ClassBType. It requires
- * access to the compiler (global parameter).
- *
- * The mixin CoreBTypes defines core BTypes that are used in the backend. Building these BTypes
- * uses classBTypeFromSymbol, hence requires access to the compiler (global).
- *
- * BTypesFromSymbols extends BTypes because the implementation of BTypes requires access to some
- * of the core btypes. They are declared in BTypes as abstract members. Note that BTypes does
- * not have access to the compiler instance.
- */
-class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
-  import int.{_, given}
-  import DottyBackendInterface.{symExtensions, _}
-
-  lazy val TransientAttr = requiredClass[scala.transient]
-  lazy val VolatileAttr = requiredClass[scala.volatile]
-
-  val bCodeAsmCommon: BCodeAsmCommon[int.type ] = new BCodeAsmCommon(int)
-  import bCodeAsmCommon._
-
-  // Why the proxy, see documentation of class [[CoreBTypes]].
-  val coreBTypes: CoreBTypesProxy[this.type] = new CoreBTypesProxy[this.type](this)
-  import coreBTypes._
-
-  final def intializeCoreBTypes(): Unit = {
-    coreBTypes.setBTypes(new CoreBTypes[this.type](this))
-  }
-
-  private[this] val perRunCaches: Caches = new Caches {
-    def newAnyRefMap[K <: AnyRef, V](): mutable.AnyRefMap[K, V] = new mutable.AnyRefMap[K, V]()
-    def newWeakMap[K, V](): mutable.WeakHashMap[K, V] = new mutable.WeakHashMap[K, V]()
-    def recordCache[T <: Clearable](cache: T): T = cache
-    def newMap[K, V](): mutable.HashMap[K, V] = new mutable.HashMap[K, V]()
-    def newSet[K](): mutable.Set[K] = new mutable.HashSet[K]
-  }
-
-  // TODO remove abstraction
-  private abstract class Caches {
-    def recordCache[T <: Clearable](cache: T): T
-    def newWeakMap[K, V](): collection.mutable.WeakHashMap[K, V]
-    def newMap[K, V](): collection.mutable.HashMap[K, V]
-    def newSet[K](): collection.mutable.Set[K]
-    def newAnyRefMap[K <: AnyRef, V](): collection.mutable.AnyRefMap[K, V]
-  }
-
-  @threadUnsafe protected lazy val classBTypeFromInternalNameMap = {
-    perRunCaches.recordCache(collection.concurrent.TrieMap.empty[String, ClassBType])
-  }
-
-  /**
-   * Cache for the method classBTypeFromSymbol.
-   */
-  @threadUnsafe private lazy val convertedClasses = perRunCaches.newMap[Symbol, ClassBType]()
-
-  /**
-   * The ClassBType for a class symbol `sym`.
-   */
-  final def classBTypeFromSymbol(classSym: Symbol): ClassBType = {
-    assert(classSym != NoSymbol, "Cannot create ClassBType from NoSymbol")
-    assert(classSym.isClass, s"Cannot create ClassBType from non-class symbol $classSym")
-    assert(
-      (!primitiveTypeMap.contains(classSym) || isCompilingPrimitive) &&
-      (classSym != defn.NothingClass && classSym != defn.NullClass),
-      s"Cannot create ClassBType for special class symbol ${classSym.showFullName}")
-
-    convertedClasses.getOrElse(classSym, {
-      val internalName = classSym.javaBinaryName
-      // We first create and add the ClassBType to the hash map before computing its info. This
-      // allows initializing cylic dependencies, see the comment on variable ClassBType._info.
-      val classBType = new ClassBType(internalName)
-      convertedClasses(classSym) = classBType
-      setClassInfo(classSym, classBType)
-    })
-  }
-
-  final def mirrorClassBTypeFromSymbol(moduleClassSym: Symbol): ClassBType = {
-    assert(moduleClassSym.isTopLevelModuleClass, s"not a top-level module class: $moduleClassSym")
-    val internalName = moduleClassSym.javaBinaryName.stripSuffix(StdNames.str.MODULE_SUFFIX)
-    val bType = ClassBType(internalName)
-    bType.info = ClassInfo(
-      superClass = Some(ObjectRef),
-      interfaces = Nil,
-      flags = asm.Opcodes.ACC_SUPER | asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_FINAL,
-      memberClasses = getMemberClasses(moduleClassSym).map(classBTypeFromSymbol),
-      nestedInfo = None
-    )
-    bType
-  }
-
-  private def setClassInfo(classSym: Symbol, classBType: ClassBType): ClassBType = {
-    val superClassSym: Symbol =  {
-      val t = classSym.asClass.superClass
-      if (t.exists) t
-      else if (classSym.is(ModuleClass)) {
-        // workaround #371
-
-        println(s"Warning: mocking up superclass for $classSym")
-        defn.ObjectClass
-      }
-      else t
-    }
-    assert(
-      if (classSym == defn.ObjectClass)
-        superClassSym == NoSymbol
-      else if (classSym.isInterface)
-        superClassSym == defn.ObjectClass
-      else
-        // A ClassBType for a primitive class (scala.Boolean et al) is only created when compiling these classes.
-        ((superClassSym != NoSymbol) && !superClassSym.isInterface) || (isCompilingPrimitive && primitiveTypeMap.contains(classSym)),
-      s"Bad superClass for $classSym: $superClassSym"
-    )
-    val superClass = if (superClassSym == NoSymbol) None
-                     else Some(classBTypeFromSymbol(superClassSym))
-
-    /**
-     * All interfaces implemented by a class, except for those inherited through the superclass.
-     * Redundant interfaces are removed unless there is a super call to them.
-     */
-    extension (sym: Symbol) def superInterfaces: List[Symbol] = {
-      val directlyInheritedTraits = sym.directlyInheritedTraits
-      val directlyInheritedTraitsSet = directlyInheritedTraits.toSet
-      val allBaseClasses = directlyInheritedTraits.iterator.flatMap(_.asClass.baseClasses.drop(1)).toSet
-      val superCalls = superCallsMap.getOrElse(sym, Set.empty)
-      val additional = (superCalls -- directlyInheritedTraitsSet).filter(_.is(Trait))
-//      if (additional.nonEmpty)
-//        println(s"$fullName: adding supertraits $additional")
-      directlyInheritedTraits.filter(t => !allBaseClasses(t) || superCalls(t)) ++ additional
-    }
-
-    val interfaces = classSym.superInterfaces.map(classBTypeFromSymbol)
-
-    val flags = javaFlags(classSym)
-
-    /* The InnerClass table of a class C must contain all nested classes of C, even if they are only
-     * declared but not otherwise referenced in C (from the bytecode or a method / field signature).
-     * We collect them here.
-     */
-    val nestedClassSymbols = {
-      // The lambdalift phase lifts all nested classes to the enclosing class, so if we collect
-      // member classes right after lambdalift, we obtain all nested classes, including local and
-      // anonymous ones.
-      val nestedClasses = getNestedClasses(classSym)
-
-      // If this is a top-level class, and it has a companion object, the member classes of the
-      // companion are added as members of the class. For example:
-      //   class C { }
-      //   object C {
-      //     class D
-      //     def f = { class E }
-      //   }
-      // The class D is added as a member of class C. The reason is that the InnerClass attribute
-      // for D will containt class "C" and NOT the module class "C$" as the outer class of D.
-      // This is done by buildNestedInfo, the reason is Java compatibility, see comment in BTypes.
-      // For consistency, the InnerClass entry for D needs to be present in C - to Java it looks
-      // like D is a member of C, not C$.
-      val linkedClass = classSym.linkedClass
-      val companionModuleMembers = {
-        if (classSym.linkedClass.isTopLevelModuleClass) getMemberClasses(classSym.linkedClass)
-        else Nil
-      }
-
-      nestedClasses ++ companionModuleMembers
-    }
-
-    /**
-     * For nested java classes, the scala compiler creates both a class and a module (and therefore
-     * a module class) symbol. For example, in `class A { class B {} }`, the nestedClassSymbols
-     * for A contain both the class B and the module class B.
-     * Here we get rid of the module class B, making sure that the class B is present.
-     */
-    val nestedClassSymbolsNoJavaModuleClasses = nestedClassSymbols.filter(s => {
-      if (s.is(JavaDefined) && s.is(ModuleClass)) {
-        // We could also search in nestedClassSymbols for s.linkedClassOfClass, but sometimes that
-        // returns NoSymbol, so it doesn't work.
-        val nb = nestedClassSymbols.count(mc => mc.name == s.name && mc.owner == s.owner)
-        // this assertion is specific to how ScalaC works. It doesn't apply to dotty, as n dotty there will be B & B$
-        // assert(nb == 2, s"Java member module without member class: $s - $nestedClassSymbols")
-        false
-      } else true
-    })
-
-    val memberClasses = nestedClassSymbolsNoJavaModuleClasses.map(classBTypeFromSymbol)
-
-    val nestedInfo = buildNestedInfo(classSym)
-
-    classBType.info = ClassInfo(superClass, interfaces, flags, memberClasses, nestedInfo)
-    classBType
-  }
-
-  /** For currently compiled classes: All locally defined classes including local classes.
-   *  The empty list for classes that are not currently compiled.
-   */
-  private def getNestedClasses(sym: Symbol): List[Symbol] = definedClasses(sym, flattenPhase)
-
-  /** For currently compiled classes: All classes that are declared as members of this class
-   *  (but not inherited ones). The empty list for classes that are not currently compiled.
-   */
-  private def getMemberClasses(sym: Symbol): List[Symbol] = definedClasses(sym, lambdaLiftPhase)
-
-  private def definedClasses(sym: Symbol, phase: Phase) =
-    if (sym.isDefinedInCurrentRun)
-      atPhase(phase) {
-        toDenot(sym).info.decls.filter(sym => sym.isClass && !sym.isEffectivelyErased)
-      }
-    else Nil
-
-  private def buildNestedInfo(innerClassSym: Symbol): Option[NestedInfo] = {
-    assert(innerClassSym.isClass, s"Cannot build NestedInfo for non-class symbol $innerClassSym")
-
-    val isNested = !innerClassSym.originalOwner.originalLexicallyEnclosingClass.is(PackageClass)
-    if (!isNested) None
-    else {
-      // See comment in BTypes, when is a class marked static in the InnerClass table.
-      val isStaticNestedClass = innerClassSym.originalOwner.originalLexicallyEnclosingClass.isOriginallyStaticOwner
-
-      // After lambdalift (which is where we are), the rawowoner field contains the enclosing class.
-      val enclosingClassSym = {
-        if (innerClassSym.isClass) {
-          atPhase(flattenPhase.prev) {
-            toDenot(innerClassSym).owner.enclosingClass
-          }
-        }
-        else atPhase(flattenPhase.prev)(innerClassSym.enclosingClass)
-      } //todo is handled specially for JavaDefined symbols in scalac
-
-      val enclosingClass: ClassBType = classBTypeFromSymbol(enclosingClassSym)
-
-      val outerName: Option[String] = {
-        if (isAnonymousOrLocalClass(innerClassSym)) {
-          None
-        } else {
-          val outerName = innerClassSym.originalOwner.originalLexicallyEnclosingClass.javaBinaryName
-          def dropModule(str: String): String =
-            if (!str.isEmpty && str.last == '$') str.take(str.length - 1) else str
-          // Java compatibility. See the big comment in BTypes that summarizes the InnerClass spec.
-          val outerNameModule =
-            if (innerClassSym.originalOwner.originalLexicallyEnclosingClass.isTopLevelModuleClass) dropModule(outerName)
-            else outerName
-          Some(outerNameModule.toString)
-        }
-      }
-
-      val innerName: Option[String] = {
-        if (innerClassSym.isAnonymousClass || innerClassSym.isAnonymousFunction) None
-        else {
-          val original = innerClassSym.initial
-          Some(atPhase(original.validFor.phaseId)(innerClassSym.name).mangledString) // moduleSuffix for module classes
-        }
-      }
-
-      Some(NestedInfo(enclosingClass, outerName, innerName, isStaticNestedClass))
-    }
-  }
-
-  /**
-   * This is basically a re-implementation of sym.isStaticOwner, but using the originalOwner chain.
-   *
-   * The problem is that we are interested in a source-level property. Various phases changed the
-   * symbol's properties in the meantime, mostly lambdalift modified (destructively) the owner.
-   * Therefore, `sym.isStatic` is not what we want. For example, in
-   *   object T { def f { object U } }
-   * the owner of U is T, so UModuleClass.isStatic is true. Phase travel does not help here.
-   */
-  extension (sym: Symbol)
-    private def isOriginallyStaticOwner: Boolean =
-      sym.is(PackageClass) || sym.is(ModuleClass) && sym.originalOwner.originalLexicallyEnclosingClass.isOriginallyStaticOwner
-
-  /**
-   * Return the Java modifiers for the given symbol.
-   * Java modifiers for classes:
-   *  - public, abstract, final, strictfp (not used)
-   * for interfaces:
-   *  - the same as for classes, without 'final'
-   * for fields:
-   *  - public, private (*)
-   *  - static, final
-   * for methods:
-   *  - the same as for fields, plus:
-   *  - abstract, synchronized (not used), strictfp (not used), native (not used)
-   * for all:
-   *  - deprecated
-   *
-   *  (*) protected cannot be used, since inner classes 'see' protected members,
-   *      and they would fail verification after lifted.
-   */
-  final def javaFlags(sym: Symbol): Int = {
-
-    // Classes are always emitted as public. This matches the behavior of Scala 2
-    // and is necessary for object deserialization to work properly, otherwise
-    // ModuleSerializationProxy may fail with an accessiblity error (see
-    // tests/run/serialize.scala and https://github.com/typelevel/cats-effect/pull/2360).
-    val privateFlag = !sym.isClass && (sym.is(Private) || (sym.isPrimaryConstructor && sym.owner.isTopLevelModuleClass))
-
-    val finalFlag = sym.is(Final) && !toDenot(sym).isClassConstructor && !sym.is(Mutable, butNot = Accessor) && !sym.enclosingClass.is(Trait)
-
-    import asm.Opcodes._
-    import GenBCodeOps.addFlagIf
-    0 .addFlagIf(privateFlag, ACC_PRIVATE)
-      .addFlagIf(!privateFlag, ACC_PUBLIC)
-      .addFlagIf(sym.is(Deferred) || sym.isOneOf(AbstractOrTrait), ACC_ABSTRACT)
-      .addFlagIf(sym.isInterface, ACC_INTERFACE)
-      .addFlagIf(finalFlag
-        // Primitives are "abstract final" to prohibit instantiation
-        // without having to provide any implementations, but that is an
-        // illegal combination of modifiers at the bytecode level so
-        // suppress final if abstract if present.
-        && !sym.isOneOf(AbstractOrTrait)
-        //  Mixin forwarders are bridges and can be final, but final bridges confuse some frameworks
-        && !sym.is(Bridge), ACC_FINAL)
-      .addFlagIf(sym.isStaticMember, ACC_STATIC)
-      .addFlagIf(sym.is(Bridge), ACC_BRIDGE | ACC_SYNTHETIC)
-      .addFlagIf(sym.is(Artifact), ACC_SYNTHETIC)
-      .addFlagIf(sym.isClass && !sym.isInterface, ACC_SUPER)
-      .addFlagIf(sym.isAllOf(JavaEnum), ACC_ENUM)
-      .addFlagIf(sym.is(JavaVarargs), ACC_VARARGS)
-      .addFlagIf(sym.is(Synchronized), ACC_SYNCHRONIZED)
-      .addFlagIf(sym.isDeprecated, ACC_DEPRECATED)
-      .addFlagIf(sym.is(Enum), ACC_ENUM)
-  }
-
-  def javaFieldFlags(sym: Symbol) = {
-    import asm.Opcodes._
-    import GenBCodeOps.addFlagIf
-    javaFlags(sym)
-      .addFlagIf(sym.hasAnnotation(TransientAttr), ACC_TRANSIENT)
-      .addFlagIf(sym.hasAnnotation(VolatileAttr), ACC_VOLATILE)
-      .addFlagIf(!sym.is(Mutable), ACC_FINAL)
-  }
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/BytecodeWriters.scala b/tests/pos-with-compiler-cc/backend/jvm/BytecodeWriters.scala
deleted file mode 100644
index 551d4f8d809e..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/BytecodeWriters.scala
+++ /dev/null
@@ -1,147 +0,0 @@
-package dotty.tools
-package backend
-package jvm
-
-import scala.language.unsafeNulls
-
-import java.io.{ DataOutputStream, FileOutputStream, IOException, File as JFile }
-import java.nio.channels.ClosedByInterruptException
-import dotty.tools.io._
-import dotty.tools.dotc.report
-
-
-/** Can't output a file due to the state of the file system. */
-class FileConflictException(msg: String, val file: AbstractFile) extends IOException(msg)
-
-/** For the last mile: turning generated bytecode in memory into
- *  something you can use.  Has implementations for writing to class
- *  files, jars, and disassembled/javap output.
- */
-trait BytecodeWriters {
-  val int: DottyBackendInterface
-  import int.{_, given}
-
-  /**
-   * @param clsName cls.getName
-   */
-  def getFile(base: AbstractFile, clsName: String, suffix: String): AbstractFile = {
-    def ensureDirectory(dir: AbstractFile): AbstractFile =
-      if (dir.isDirectory) dir
-      else throw new FileConflictException(s"${base.path}/$clsName$suffix: ${dir.path} is not a directory", dir)
-    var dir = base
-    val pathParts = clsName.split("[./]").toList
-    for (part <- pathParts.init) dir = ensureDirectory(dir) subdirectoryNamed part
-    ensureDirectory(dir) fileNamed pathParts.last + suffix
-  }
-  def getFile(sym: Symbol, clsName: String, suffix: String): AbstractFile =
-    getFile(outputDirectory, clsName, suffix)
-
-  def factoryNonJarBytecodeWriter(): BytecodeWriter = {
-    val emitAsmp  = None
-    val doDump    = dumpClasses
-    (emitAsmp.isDefined, doDump.isDefined) match {
-      case (false, false) => new ClassBytecodeWriter { }
-      case (false, true ) => new ClassBytecodeWriter with DumpBytecodeWriter { }
-      case (true,  false) => new ClassBytecodeWriter with AsmpBytecodeWriter
-      case (true,  true ) => new ClassBytecodeWriter with AsmpBytecodeWriter with DumpBytecodeWriter { }
-    }
-  }
-
-  trait BytecodeWriter {
-    def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile): Unit
-    def close(): Unit = ()
-  }
-
-  class DirectToJarfileWriter(jfile: JFile) extends BytecodeWriter {
-    val writer = new Jar(jfile).jarWriter()
-
-    def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile): Unit = {
-      assert(outfile == null,
-             "The outfile formal param is there just because ClassBytecodeWriter overrides this method and uses it.")
-      val path = jclassName + ".class"
-      val out  = writer.newOutputStream(path)
-
-      try out.write(jclassBytes, 0, jclassBytes.length)
-      finally out.flush()
-
-      report.informProgress("added " + label + path + " to jar")
-    }
-    override def close() = writer.close()
-  }
-
-  /*
-   * The ASM textual representation for bytecode overcomes disadvantages of javap output in three areas:
-   *    (a) pickle dingbats undecipherable to the naked eye;
-   *    (b) two constant pools, while having identical contents, are displayed differently due to physical layout.
-   *    (c) stack maps (classfile version 50 and up) are displayed in encoded form by javap,
-   *        their expansion by ASM is more readable.
-   *
-   * */
-  trait AsmpBytecodeWriter extends BytecodeWriter {
-    import scala.tools.asm
-
-    private val baseDir = new Directory(None.get).createDirectory() // FIXME missing directoy
-      // new needed here since resolution of user-defined `apply` methods is ambiguous, and we want the constructor.
-
-    private def emitAsmp(jclassBytes: Array[Byte], asmpFile: dotty.tools.io.File): Unit = {
-      val pw = asmpFile.printWriter()
-      try {
-        val cnode = new ClassNode1()
-        val cr    = new asm.ClassReader(jclassBytes)
-        cr.accept(cnode, 0)
-        val trace = new scala.tools.asm.util.TraceClassVisitor(new java.io.PrintWriter(new java.io.StringWriter()))
-        cnode.accept(trace)
-        trace.p.print(pw)
-      }
-      finally pw.close()
-    }
-
-    abstract override def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile): Unit = {
-      super.writeClass(label, jclassName, jclassBytes, outfile)
-
-      val segments = jclassName.split("[./]")
-      val asmpFile = segments.foldLeft(baseDir: Path)(_ / _).changeExtension("asmp").toFile
-
-      asmpFile.parent.createDirectory()
-      emitAsmp(jclassBytes, asmpFile)
-    }
-  }
-
-  trait ClassBytecodeWriter extends BytecodeWriter {
-    def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile): Unit = {
-      assert(outfile != null,
-             "Precisely this override requires its invoker to hand out a non-null AbstractFile.")
-      val outstream = new DataOutputStream(outfile.bufferedOutput)
-
-      try outstream.write(jclassBytes, 0, jclassBytes.length)
-      catch case ex: ClosedByInterruptException =>
-        try
-          outfile.delete() // don't leave an empty or half-written classfile around after an interrupt
-        catch
-          case _: Throwable =>
-        throw ex
-      finally outstream.close()
-      report.informProgress("wrote '" + label + "' to " + outfile)
-    }
-  }
-
-  trait DumpBytecodeWriter extends BytecodeWriter {
-    val baseDir = Directory(dumpClasses.get).createDirectory()
-
-    abstract override def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile): Unit = {
-      super.writeClass(label, jclassName, jclassBytes, outfile)
-
-      val pathName = jclassName
-      val dumpFile = pathName.split("[./]").foldLeft(baseDir: Path) (_ / _).changeExtension("class").toFile
-      dumpFile.parent.createDirectory()
-      val outstream = new DataOutputStream(new FileOutputStream(dumpFile.path))
-
-      try outstream.write(jclassBytes, 0, jclassBytes.length)
-      finally outstream.close()
-    }
-  }
-
-  private def dumpClasses: Option[String] =
-    if (ctx.settings.Ydumpclasses.isDefault) None
-    else Some(ctx.settings.Ydumpclasses.value)
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/ClassNode1.java b/tests/pos-with-compiler-cc/backend/jvm/ClassNode1.java
deleted file mode 100644
index c5594ae3dea6..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/ClassNode1.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * 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.backend.jvm;
-
-import scala.tools.asm.MethodVisitor;
-import scala.tools.asm.Opcodes;
-import scala.tools.asm.tree.ClassNode;
-import scala.tools.asm.tree.MethodNode;
-
-/**
- * A subclass of {@link ClassNode} to customize the representation of
- * label nodes with {@link LabelNode1}.
- */
-public class ClassNode1 extends ClassNode {
-    public ClassNode1() {
-        this(Opcodes.ASM6);
-    }
-
-    public ClassNode1(int api) {
-        super(api);
-    }
-
-    @Override
-    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
-        MethodNode method = new MethodNode1(access, name, descriptor, signature, exceptions);
-        methods.add(method);
-        return method;
-    }
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/CollectSuperCalls.scala b/tests/pos-with-compiler-cc/backend/jvm/CollectSuperCalls.scala
deleted file mode 100644
index 299c1c75d6cf..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/CollectSuperCalls.scala
+++ /dev/null
@@ -1,48 +0,0 @@
-package dotty.tools.backend.jvm
-
-import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.core.Contexts._
-import dotty.tools.dotc.core.Phases._
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.core.Flags.Trait
-import dotty.tools.dotc.transform.MegaPhase.MiniPhase
-
-/** Collect all super calls to trait members.
- *
- *  For each super reference to trait member, register a call from the current class to the
- *  owner of the referenced member.
- *
- *  This information is used to know if it is safe to remove a redundant mixin class.
- *  A redundant mixin class is one that is implemented by another mixin class. As the
- *  methods in a redundant mixin class could be implemented with a default abstract method,
- *  the redundant mixin class could be required as a parent by the JVM.
- */
-class CollectSuperCalls extends MiniPhase {
-  import tpd._
-
-  override def phaseName: String = CollectSuperCalls.name
-
-  override def description: String = CollectSuperCalls.description
-
-  override def transformSelect(tree: Select)(using Context): Tree = {
-    tree.qualifier match {
-      case sup: Super =>
-        if (tree.symbol.owner.is(Trait))
-          registerSuperCall(ctx.owner.enclosingClass.asClass, tree.symbol.owner.asClass)
-      case _ =>
-    }
-    tree
-  }
-
-  private def registerSuperCall(sym: ClassSymbol, calls: ClassSymbol)(using Context) = {
-    genBCodePhase match {
-      case genBCodePhase: GenBCode =>
-        genBCodePhase.registerSuperCall(sym, calls)
-      case _ =>
-    }
-  }
-}
-
-object CollectSuperCalls:
-  val name: String = "collectSuperCalls"
-  val description: String = "find classes that are called with super"
diff --git a/tests/pos-with-compiler-cc/backend/jvm/CoreBTypes.scala b/tests/pos-with-compiler-cc/backend/jvm/CoreBTypes.scala
deleted file mode 100644
index d5fce3f53627..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/CoreBTypes.scala
+++ /dev/null
@@ -1,294 +0,0 @@
-package dotty.tools
-package backend
-package jvm
-
-
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.transform.Erasure
-import scala.tools.asm.{Handle, Opcodes}
-import dotty.tools.dotc.core.StdNames
-
-/**
- * Core BTypes and some other definitions. The initialization of these definitions requies access
- * to symbols / types (global).
- *
- * The symbols used to initialize the ClassBTypes may change from one compiler run to the next. To
- * make sure the definitions are consistent with the symbols in the current run, the
- * `intializeCoreBTypes` method in BTypesFromSymbols creates a new instance of CoreBTypes in each
- * compiler run.
- *
- * The class BTypesFromSymbols does not directly reference CoreBTypes, but CoreBTypesProxy. The
- * reason is that having a `var bTypes: CoreBTypes` would not allow `import bTypes._`. Instead, the
- * proxy class holds a `CoreBTypes` in a variable field and forwards to this instance.
- *
- * The definitions in `CoreBTypes` need to be lazy vals to break an initialization cycle. When
- * creating a new instance to assign to the proxy, the `classBTypeFromSymbol` invoked in the
- * constructor will actucally go through the proxy. The lazy vals make sure the instance is assigned
- * in the proxy before the fields are initialized.
- *
- * Note: if we did not re-create the core BTypes on each compiler run, BType.classBTypeFromInternalNameMap
- * could not be a perRunCache anymore: the classes defeined here need to be in that map, they are
- * added when the ClassBTypes are created. The per run cache removes them, so they would be missing
- * in the second run.
- */
-class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: DottyBackendInterface]](val bTypes: BTFS) {
-  import bTypes._
-  import int.given
-  import DottyBackendInterface._
-
-  //import global._
-  //import rootMirror.{requiredClass, getClassIfDefined}
-  //import definitions._
-
-  /**
-   * Maps primitive types to their corresponding PrimitiveBType. The map is defined lexically above
-   * the first use of `classBTypeFromSymbol` because that method looks at the map.
-   */
-  lazy val primitiveTypeMap: Map[Symbol, PrimitiveBType] = Map(
-    defn.UnitClass    -> UNIT,
-    defn.BooleanClass -> BOOL,
-    defn.CharClass    -> CHAR,
-    defn.ByteClass    -> BYTE,
-    defn.ShortClass   -> SHORT,
-    defn.IntClass     -> INT,
-    defn.LongClass    -> LONG,
-    defn.FloatClass   -> FLOAT,
-    defn.DoubleClass  -> DOUBLE
-  )
-
-  private lazy val BOXED_UNIT    : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.Void])
-  private lazy val BOXED_BOOLEAN : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.Boolean])
-  private lazy val BOXED_BYTE    : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.Byte])
-  private lazy val BOXED_SHORT   : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.Short])
-  private lazy val BOXED_CHAR    : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.Character])
-  private lazy val BOXED_INT     : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.Integer])
-  private lazy val BOXED_LONG    : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.Long])
-  private lazy val BOXED_FLOAT   : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.Float])
-  private lazy val BOXED_DOUBLE  : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.Double])
-
-  /**
-   * Map from primitive types to their boxed class type. Useful when pushing class literals onto the
-   * operand stack (ldc instruction taking a class literal), see genConstant.
-   */
-  lazy val boxedClassOfPrimitive: Map[PrimitiveBType, ClassBType] = Map(
-    UNIT   -> BOXED_UNIT,
-    BOOL   -> BOXED_BOOLEAN,
-    BYTE   -> BOXED_BYTE,
-    SHORT  -> BOXED_SHORT,
-    CHAR   -> BOXED_CHAR,
-    INT    -> BOXED_INT,
-    LONG   -> BOXED_LONG,
-    FLOAT  -> BOXED_FLOAT,
-    DOUBLE -> BOXED_DOUBLE
-  )
-
-  lazy val boxedClasses: Set[ClassBType] = boxedClassOfPrimitive.values.toSet
-
-  /**
-   * Maps the method symbol for a box method to the boxed type of the result. For example, the
-   * method symbol for `Byte.box()` is mapped to the ClassBType `java/lang/Byte`.
-   */
-  lazy val boxResultType: Map[Symbol, ClassBType] = {
-    val boxMethods = defn.ScalaValueClasses().map{x => // @darkdimius Are you sure this should be a def?
-      (x, Erasure.Boxing.boxMethod(x.asClass))
-    }.toMap
-    for ((valueClassSym, boxMethodSym) <- boxMethods)
-    yield boxMethodSym -> boxedClassOfPrimitive(primitiveTypeMap(valueClassSym))
-  }
-
-  /**
-   * Maps the method symbol for an unbox method to the primitive type of the result.
-   * For example, the method symbol for `Byte.unbox()`) is mapped to the PrimitiveBType BYTE. */
-  lazy val unboxResultType: Map[Symbol, PrimitiveBType] = {
-    val unboxMethods: Map[Symbol, Symbol] =
-      defn.ScalaValueClasses().map(x => (x, Erasure.Boxing.unboxMethod(x.asClass))).toMap
-    for ((valueClassSym, unboxMethodSym) <- unboxMethods)
-    yield unboxMethodSym -> primitiveTypeMap(valueClassSym)
-  }
-
-  /*
-   * srNothingRef and srNullRef exist at run-time only. They are the bytecode-level manifestation (in
-   * method signatures only) of what shows up as NothingClass (scala.Nothing) resp. NullClass (scala.Null) in Scala ASTs.
-   *
-   * Therefore, when srNothingRef or srNullRef are to be emitted, a mapping is needed: the internal
-   * names of NothingClass and NullClass can't be emitted as-is.
-   * TODO @lry Once there's a 2.11.3 starr, use the commented argument list. The current starr crashes on the type literal `scala.runtime.Nothing$`
-   */
-  lazy val srNothingRef : ClassBType = classBTypeFromSymbol(requiredClass("scala.runtime.Nothing$")) // (requiredClass[scala.runtime.Nothing$])
-  lazy val srNullRef    : ClassBType = classBTypeFromSymbol(requiredClass("scala.runtime.Null$"))    // (requiredClass[scala.runtime.Null$])
-
-  lazy val ObjectRef   : ClassBType = classBTypeFromSymbol(defn.ObjectClass)
-  lazy val StringRef                   : ClassBType = classBTypeFromSymbol(defn.StringClass)
-  lazy val jlStringBuilderRef          : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.StringBuilder])
-  lazy val jlStringBufferRef           : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.StringBuffer])
-  lazy val jlCharSequenceRef           : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.CharSequence])
-  lazy val jlClassRef                  : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.Class[_]])
-  lazy val jlThrowableRef              : ClassBType = classBTypeFromSymbol(defn.ThrowableClass)
-  lazy val jlCloneableRef              : ClassBType = classBTypeFromSymbol(defn.JavaCloneableClass)        // java/lang/Cloneable
-  lazy val jioSerializableRef          : ClassBType = classBTypeFromSymbol(requiredClass[java.io.Serializable])     // java/io/Serializable
-  lazy val jlClassCastExceptionRef     : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.ClassCastException])   // java/lang/ClassCastException
-  lazy val jlIllegalArgExceptionRef    : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.IllegalArgumentException])
-  lazy val jliSerializedLambdaRef      : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.invoke.SerializedLambda])
-  
-  lazy val srBoxesRunTimeRef: ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.BoxesRunTime])
-
-  private lazy val jliCallSiteRef              : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.invoke.CallSite])
-  private lazy val jliLambdaMetafactoryRef     : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.invoke.LambdaMetafactory])
-  private lazy val jliMethodHandleRef          : ClassBType = classBTypeFromSymbol(defn.MethodHandleClass)
-  private lazy val jliMethodHandlesLookupRef   : ClassBType = classBTypeFromSymbol(defn.MethodHandlesLookupClass)
-  private lazy val jliMethodTypeRef            : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.invoke.MethodType])
-  private lazy val jliStringConcatFactoryRef   : ClassBType = classBTypeFromSymbol(requiredClass("java.lang.invoke.StringConcatFactory")) // since JDK 9
-  private lazy val srLambdaDeserialize         : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.LambdaDeserialize]) 
-
-  lazy val jliLambdaMetaFactoryMetafactoryHandle: Handle = new Handle(
-    Opcodes.H_INVOKESTATIC,
-    jliLambdaMetafactoryRef.internalName,
-    "metafactory",
-    MethodBType(
-      List(jliMethodHandlesLookupRef, StringRef, jliMethodTypeRef, jliMethodTypeRef, jliMethodHandleRef, jliMethodTypeRef),
-      jliCallSiteRef
-    ).descriptor,
-    /* itf = */ false)
-
-  lazy val jliLambdaMetaFactoryAltMetafactoryHandle: Handle = new Handle(
-    Opcodes.H_INVOKESTATIC,
-    jliLambdaMetafactoryRef.internalName,
-    "altMetafactory",
-    MethodBType(
-      List(jliMethodHandlesLookupRef, StringRef, jliMethodTypeRef, ArrayBType(ObjectRef)),
-      jliCallSiteRef
-    ).descriptor,
-    /* itf = */ false)
-    
-  lazy val jliLambdaDeserializeBootstrapHandle: Handle = new Handle(
-    Opcodes.H_INVOKESTATIC,
-    srLambdaDeserialize.internalName,
-    "bootstrap",
-    MethodBType(
-      List(jliMethodHandlesLookupRef, StringRef, jliMethodTypeRef, ArrayBType(jliMethodHandleRef)),
-      jliCallSiteRef
-    ).descriptor,
-    /* itf = */ false)
-
-  lazy val jliStringConcatFactoryMakeConcatWithConstantsHandle = new Handle(
-    Opcodes.H_INVOKESTATIC,
-    jliStringConcatFactoryRef.internalName,
-    "makeConcatWithConstants",
-    MethodBType(
-      List(jliMethodHandlesLookupRef, StringRef, jliMethodTypeRef, StringRef, ArrayBType(ObjectRef)),
-      jliCallSiteRef
-    ).descriptor,
-    /* itf = */ false)
-  
-  /**
-   * Methods in scala.runtime.BoxesRuntime
-   */
-  lazy val asmBoxTo  : Map[BType, MethodNameAndType] = Map(
-    BOOL   -> MethodNameAndType("boxToBoolean",   MethodBType(List(BOOL),   BOXED_BOOLEAN)),
-    BYTE   -> MethodNameAndType("boxToByte",      MethodBType(List(BYTE),   BOXED_BYTE)),
-    CHAR   -> MethodNameAndType("boxToCharacter", MethodBType(List(CHAR),   BOXED_CHAR)),
-    SHORT  -> MethodNameAndType("boxToShort",     MethodBType(List(SHORT),  BOXED_SHORT)),
-    INT    -> MethodNameAndType("boxToInteger",   MethodBType(List(INT),    BOXED_INT)),
-    LONG   -> MethodNameAndType("boxToLong",      MethodBType(List(LONG),   BOXED_LONG)),
-    FLOAT  -> MethodNameAndType("boxToFloat",     MethodBType(List(FLOAT),  BOXED_FLOAT)),
-    DOUBLE -> MethodNameAndType("boxToDouble",    MethodBType(List(DOUBLE), BOXED_DOUBLE))
-  )
-
-  lazy val asmUnboxTo: Map[BType, MethodNameAndType] = Map(
-    BOOL   -> MethodNameAndType("unboxToBoolean", MethodBType(List(ObjectRef), BOOL)),
-    BYTE   -> MethodNameAndType("unboxToByte",    MethodBType(List(ObjectRef), BYTE)),
-    CHAR   -> MethodNameAndType("unboxToChar",    MethodBType(List(ObjectRef), CHAR)),
-    SHORT  -> MethodNameAndType("unboxToShort",   MethodBType(List(ObjectRef), SHORT)),
-    INT    -> MethodNameAndType("unboxToInt",     MethodBType(List(ObjectRef), INT)),
-    LONG   -> MethodNameAndType("unboxToLong",    MethodBType(List(ObjectRef), LONG)),
-    FLOAT  -> MethodNameAndType("unboxToFloat",   MethodBType(List(ObjectRef), FLOAT)),
-    DOUBLE -> MethodNameAndType("unboxToDouble",  MethodBType(List(ObjectRef), DOUBLE))
-  )
-
-  lazy val typeOfArrayOp: Map[Int, BType] = {
-    import dotty.tools.backend.ScalaPrimitivesOps._
-    Map(
-        (List(ZARRAY_LENGTH, ZARRAY_GET, ZARRAY_SET) map (_ -> BOOL))   ++
-        (List(BARRAY_LENGTH, BARRAY_GET, BARRAY_SET) map (_ -> BYTE))   ++
-        (List(SARRAY_LENGTH, SARRAY_GET, SARRAY_SET) map (_ -> SHORT))  ++
-        (List(CARRAY_LENGTH, CARRAY_GET, CARRAY_SET) map (_ -> CHAR))   ++
-        (List(IARRAY_LENGTH, IARRAY_GET, IARRAY_SET) map (_ -> INT))    ++
-        (List(LARRAY_LENGTH, LARRAY_GET, LARRAY_SET) map (_ -> LONG))   ++
-        (List(FARRAY_LENGTH, FARRAY_GET, FARRAY_SET) map (_ -> FLOAT))  ++
-        (List(DARRAY_LENGTH, DARRAY_GET, DARRAY_SET) map (_ -> DOUBLE)) ++
-        (List(OARRAY_LENGTH, OARRAY_GET, OARRAY_SET) map (_ -> ObjectRef)) : _*
-    )
-  }
-}
-
-/**
- * This trait make some core BTypes availalbe that don't depend on a Global instance. Some core
- * BTypes are required to be accessible in the BTypes trait, which does not have access to Global.
- *
- * BTypes cannot refer to CoreBTypesProxy because some of its members depend on global, for example
- * the type Symbol in
- *   def primitiveTypeMap: Map[Symbol, PrimitiveBType]
- */
-trait CoreBTypesProxyGlobalIndependent[BTS <: BTypes] {
-  val bTypes: BTS
-  import bTypes._
-
-  def boxedClasses: Set[ClassBType]
-
-  def srNothingRef : ClassBType
-  def srNullRef    : ClassBType
-
-  def ObjectRef          : ClassBType
-  def jlCloneableRef     : ClassBType
-  def jiSerializableRef  : ClassBType
-}
-
-/**
- * See comment in class [[CoreBTypes]].
- */
-final class CoreBTypesProxy[BTFS <: BTypesFromSymbols[_ <: DottyBackendInterface]](val bTypes: BTFS) extends CoreBTypesProxyGlobalIndependent[BTFS] {
-  import bTypes._
-
-  private var _coreBTypes: CoreBTypes[bTypes.type] = _
-  def setBTypes(coreBTypes: CoreBTypes[BTFS]): Unit = {
-    _coreBTypes = coreBTypes.asInstanceOf[CoreBTypes[bTypes.type]]
-  }
-
-  def primitiveTypeMap: Map[Symbol, PrimitiveBType] = _coreBTypes.primitiveTypeMap
-
-  def boxedClasses: Set[ClassBType] = _coreBTypes.boxedClasses
-
-  def boxedClassOfPrimitive: Map[PrimitiveBType, ClassBType] = _coreBTypes.boxedClassOfPrimitive
-
-  def boxResultType: Map[Symbol, ClassBType] = _coreBTypes.boxResultType
-
-  def unboxResultType: Map[Symbol, PrimitiveBType] = _coreBTypes.unboxResultType
-
-  def srNothingRef : ClassBType = _coreBTypes.srNothingRef
-  def srNullRef    : ClassBType = _coreBTypes.srNullRef
-
-  def ObjectRef                   : ClassBType = _coreBTypes.ObjectRef
-  def StringRef                   : ClassBType = _coreBTypes.StringRef
-  def jlStringBuilderRef          : ClassBType = _coreBTypes.jlStringBuilderRef
-  def jlStringBufferRef           : ClassBType = _coreBTypes.jlStringBufferRef
-  def jlCharSequenceRef           : ClassBType = _coreBTypes.jlCharSequenceRef
-  def jlClassRef                  : ClassBType = _coreBTypes.jlClassRef
-  def jlThrowableRef              : ClassBType = _coreBTypes.jlThrowableRef
-  def jlCloneableRef              : ClassBType = _coreBTypes.jlCloneableRef
-  def jiSerializableRef           : ClassBType = _coreBTypes.jioSerializableRef
-  def jlClassCastExceptionRef     : ClassBType = _coreBTypes.jlClassCastExceptionRef
-  def jlIllegalArgExceptionRef    : ClassBType = _coreBTypes.jlIllegalArgExceptionRef
-  def jliSerializedLambdaRef      : ClassBType = _coreBTypes.jliSerializedLambdaRef
-
-  def srBoxesRuntimeRef: ClassBType = _coreBTypes.srBoxesRunTimeRef
-
-  def jliLambdaMetaFactoryMetafactoryHandle    : Handle = _coreBTypes.jliLambdaMetaFactoryMetafactoryHandle
-  def jliLambdaMetaFactoryAltMetafactoryHandle : Handle = _coreBTypes.jliLambdaMetaFactoryAltMetafactoryHandle
-  def jliLambdaDeserializeBootstrapHandle      : Handle = _coreBTypes.jliLambdaDeserializeBootstrapHandle
-  def jliStringConcatFactoryMakeConcatWithConstantsHandle: Handle = _coreBTypes.jliStringConcatFactoryMakeConcatWithConstantsHandle
-  
-  def asmBoxTo  : Map[BType, MethodNameAndType] = _coreBTypes.asmBoxTo
-  def asmUnboxTo: Map[BType, MethodNameAndType] = _coreBTypes.asmUnboxTo
-
-  def typeOfArrayOp: Map[Int, BType] = _coreBTypes.typeOfArrayOp
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/DottyBackendInterface.scala b/tests/pos-with-compiler-cc/backend/jvm/DottyBackendInterface.scala
deleted file mode 100644
index 6ce434015b8c..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/DottyBackendInterface.scala
+++ /dev/null
@@ -1,204 +0,0 @@
-package dotty.tools.backend.jvm
-
-import scala.language.unsafeNulls
-
-import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.core.Flags._
-import dotty.tools.dotc.transform.SymUtils._
-import java.io.{File => _}
-
-import scala.reflect.ClassTag
-import dotty.tools.io.AbstractFile
-import dotty.tools.dotc.core._
-import Contexts._
-import Types._
-import Symbols._
-import Phases._
-import Decorators.em
-
-import dotty.tools.dotc.util.ReadOnlyMap
-import dotty.tools.dotc.report
-
-import tpd._
-
-import StdNames.nme
-import NameKinds.LazyBitMapName
-import Names.Name
-
-class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap: ReadOnlyMap[Symbol, Set[ClassSymbol]])(using val ctx: DetachedContext) {
-
-  private val desugared = new java.util.IdentityHashMap[Type, tpd.Select]
-
-  def cachedDesugarIdent(i: Ident): Option[tpd.Select] = {
-    var found = desugared.get(i.tpe)
-    if (found == null) {
-      tpd.desugarIdent(i) match {
-        case sel: tpd.Select =>
-          desugared.put(i.tpe, sel)
-          found = sel
-        case _ =>
-      }
-    }
-    if (found == null) None else Some(found)
-  }
-
-  object DesugaredSelect extends DeconstructorCommon[tpd.Tree] {
-
-    var desugared: tpd.Select = null
-
-    override def isEmpty: Boolean =
-      desugared eq null
-
-    def _1: Tree =  desugared.qualifier
-
-    def _2: Name = desugared.name
-
-    override def unapply(s: tpd.Tree): this.type = {
-      s match {
-        case t: tpd.Select => desugared = t
-        case t: Ident  =>
-          cachedDesugarIdent(t) match {
-            case Some(t) => desugared = t
-            case None => desugared = null
-          }
-        case _ => desugared = null
-      }
-
-      this
-    }
-  }
-
-  object ArrayValue extends DeconstructorCommon[tpd.JavaSeqLiteral] {
-    def _1: Type = field.tpe match {
-      case JavaArrayType(elem) => elem
-      case _ =>
-        report.error(em"JavaSeqArray with type ${field.tpe} reached backend: $field", ctx.source.atSpan(field.span))
-        UnspecifiedErrorType
-    }
-    def _2: List[Tree] = field.elems
-  }
-
-  abstract class DeconstructorCommon[T >: Null <: AnyRef] {
-    var field: T = null
-    def get: this.type = this
-    def isEmpty: Boolean = field eq null
-    def isDefined = !isEmpty
-    def unapply(s: T): this.type ={
-      field = s
-      this
-    }
-  }
-
-}
-
-object DottyBackendInterface {
-
-  private def erasureString(clazz: Class[_]): String = {
-    if (clazz.isArray) "Array[" + erasureString(clazz.getComponentType) + "]"
-    else clazz.getName
-  }
-
-  def requiredClass(str: String)(using Context): ClassSymbol =
-    Symbols.requiredClass(str)
-
-  def requiredClass[T](using evidence: ClassTag[T], ctx: Context): Symbol =
-    requiredClass(erasureString(evidence.runtimeClass))
-
-  def requiredModule(str: String)(using Context): Symbol =
-    Symbols.requiredModule(str)
-
-  def requiredModule[T](using evidence: ClassTag[T], ctx: Context): Symbol = {
-    val moduleName = erasureString(evidence.runtimeClass)
-    val className = if (moduleName.endsWith("$")) moduleName.dropRight(1)  else moduleName
-    requiredModule(className)
-  }
-
-  given symExtensions: AnyRef with
-    extension (sym: Symbol)
-
-      def isInterface(using Context): Boolean = (sym.is(PureInterface)) || sym.is(Trait)
-
-      def isStaticConstructor(using Context): Boolean = (sym.isStaticMember && sym.isClassConstructor) || (sym.name eq nme.STATIC_CONSTRUCTOR)
-
-      /** Fields of static modules will be static at backend
-       *
-       *  Note that lazy val encoding assumes bitmap fields are non-static.
-       *  See also `genPlainClass` in `BCodeSkelBuilder.scala`.
-       *
-       *  TODO: remove the special handing of `LazyBitMapName` once we swtich to
-       *        the new lazy val encoding: https://github.com/scala/scala3/issues/7140
-       */
-      def isStaticModuleField(using Context): Boolean =
-        sym.owner.isStaticModuleClass && sym.isField && !sym.name.is(LazyBitMapName)
-
-      def isStaticMember(using Context): Boolean = (sym ne NoSymbol) &&
-        (sym.is(JavaStatic) || sym.isScalaStatic || sym.isStaticModuleField)
-        // guard against no sumbol cause this code is executed to select which call type(static\dynamic) to use to call array.clone
-
-      /**
-      * True for module classes of modules that are top-level or owned only by objects. Module classes
-      * for such objects will get a MODULE$ flag and a corresponding static initializer.
-      */
-      def isStaticModuleClass(using Context): Boolean =
-        (sym.is(Module)) && {
-          // scalac uses atPickling here
-          // this would not work if modules are created after pickling
-          // for example by specialization
-          val original = toDenot(sym).initial
-          val validity = original.validFor
-          atPhase(validity.phaseId) {
-            toDenot(sym).isStatic
-          }
-        }
-
-
-
-      def originalLexicallyEnclosingClass(using Context): Symbol =
-        // used to populate the EnclosingMethod attribute.
-        // it is very tricky in presence of classes(and annonymous classes) defined inside supper calls.
-        if (sym.exists) {
-          val validity = toDenot(sym).initial.validFor
-          atPhase(validity.phaseId) {
-            toDenot(sym).lexicallyEnclosingClass
-          }
-        } else NoSymbol
-
-      /**
-      * True for module classes of package level objects. The backend will generate a mirror class for
-      * such objects.
-      */
-      def isTopLevelModuleClass(using Context): Boolean =
-        sym.is(ModuleClass) &&
-        atPhase(flattenPhase) {
-          toDenot(sym).owner.is(PackageClass)
-        }
-
-      def javaSimpleName(using Context): String = toDenot(sym).name.mangledString
-      def javaClassName(using Context): String = toDenot(sym).fullName.mangledString
-      def javaBinaryName(using Context): String = javaClassName.replace('.', '/')
-
-    end extension
-
-  end symExtensions
-
-  private val primitiveCompilationUnits = Set(
-    "Unit.scala",
-    "Boolean.scala",
-    "Char.scala",
-    "Byte.scala",
-    "Short.scala",
-    "Int.scala",
-    "Float.scala",
-    "Long.scala",
-    "Double.scala"
-  )
-
-  /**
-   * True if the current compilation unit is of a primitive class (scala.Boolean et al).
-   * Used only in assertions.
-   */
-  def isCompilingPrimitive(using Context) = {
-    primitiveCompilationUnits(ctx.compilationUnit.source.file.name)
-  }
-
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/GenBCode.scala b/tests/pos-with-compiler-cc/backend/jvm/GenBCode.scala
deleted file mode 100644
index 3bc9fb5592ee..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/GenBCode.scala
+++ /dev/null
@@ -1,672 +0,0 @@
-package dotty.tools.backend.jvm
-
-import scala.language.unsafeNulls
-
-import dotty.tools.dotc.CompilationUnit
-import dotty.tools.dotc.ast.Trees.{PackageDef, ValDef}
-import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.core.Phases.Phase
-
-import scala.collection.mutable
-import scala.jdk.CollectionConverters._
-import dotty.tools.dotc.transform.SymUtils._
-import dotty.tools.dotc.interfaces
-import dotty.tools.dotc.report
-
-import dotty.tools.dotc.util.SourceFile
-import java.util.Optional
-
-import dotty.tools.dotc.core._
-import dotty.tools.dotc.sbt.ExtractDependencies
-import Contexts._
-import Phases._
-import Symbols._
-import Decorators.em
-
-import java.io.DataOutputStream
-import java.nio.channels.ClosedByInterruptException
-
-import dotty.tools.tasty.{ TastyBuffer, TastyHeaderUnpickler, UnpicklerConfig }
-import dotty.tools.tasty.core.TastyUnpickler
-
-import scala.tools.asm
-import scala.tools.asm.Handle
-import scala.tools.asm.tree._
-import tpd._
-import StdNames._
-import dotty.tools.io._
-import scala.tools.asm.MethodTooLargeException
-import scala.tools.asm.ClassTooLargeException
-
-class GenBCode extends Phase {
-
-  override def phaseName: String = GenBCode.name
-
-  override def description: String = GenBCode.description
-
-  private val superCallsMap = new MutableSymbolMap[Set[ClassSymbol]]
-  def registerSuperCall(sym: Symbol, calls: ClassSymbol): Unit = {
-    val old = superCallsMap.getOrElse(sym, Set.empty)
-    superCallsMap.update(sym, old + calls)
-  }
-
-  private val entryPoints = new mutable.HashSet[String]()
-  def registerEntryPoint(s: String): Unit = entryPoints += s
-
-  private var myOutput: AbstractFile = _
-
-  private def outputDir(using Context): AbstractFile = {
-    if (myOutput eq null)
-      myOutput = ctx.settings.outputDir.value
-    myOutput
-  }
-
-  private var myPrimitives: DottyPrimitives = null
-
-  override def run(using Context): Unit =
-    inDetachedContext: ctx ?=>
-      if myPrimitives == null then myPrimitives = new DottyPrimitives(ctx)
-      new GenBCodePipeline(
-        DottyBackendInterface(outputDir, superCallsMap),
-        myPrimitives
-      ).run(ctx.compilationUnit.tpdTree)
-
-
-  override def runOn(units: List[CompilationUnit])(using Context): List[CompilationUnit] = {
-    outputDir match
-      case jar: JarArchive =>
-        updateJarManifestWithMainClass(jar, entryPoints.toList)
-      case _ =>
-    try super.runOn(units)
-    finally outputDir match {
-      case jar: JarArchive =>
-        if (ctx.run.nn.suspendedUnits.nonEmpty)
-          // If we close the jar the next run will not be able to write on the jar.
-          // But if we do not close it we cannot use it as part of the macro classpath of the suspended files.
-          report.error("Can not suspend and output to a jar at the same time. See suspension with -Xprint-suspension.")
-
-        jar.close()
-      case _ =>
-    }
-  }
-
-  private def updateJarManifestWithMainClass(jarArchive: JarArchive, entryPoints: List[String])(using Context): Unit =
-    val mainClass = Option.when(!ctx.settings.XmainClass.isDefault)(ctx.settings.XmainClass.value).orElse {
-      entryPoints match
-        case List(mainClass) =>
-          Some(mainClass)
-        case Nil =>
-          report.warning("No Main-Class designated or discovered.")
-          None
-        case mcs =>
-          report.warning(s"No Main-Class due to multiple entry points:\n  ${mcs.mkString("\n  ")}")
-          None
-    }
-    mainClass.map { mc =>
-      val manifest = Jar.WManifest()
-      manifest.mainClass = mc
-      val file = jarArchive.subdirectoryNamed("META-INF").fileNamed("MANIFEST.MF")
-      val os = file.output
-      manifest.underlying.write(os)
-      os.close()
-    }
-  end updateJarManifestWithMainClass
-}
-
-object GenBCode {
-  val name: String = "genBCode"
-  val description: String = "generate JVM bytecode"
-}
-
-class GenBCodePipeline(val int: DottyBackendInterface, val primitives: DottyPrimitives)(using DetachedContext) extends BCodeSyncAndTry {
-  import DottyBackendInterface.symExtensions
-
-  private var tree: Tree = _
-
-  private val sourceFile: SourceFile = ctx.compilationUnit.source
-
-  /** Convert a `dotty.tools.io.AbstractFile` into a
-   *  `dotty.tools.dotc.interfaces.AbstractFile`.
-   */
-  private def convertAbstractFile(absfile: dotty.tools.io.AbstractFile): interfaces.AbstractFile =
-    new interfaces.AbstractFile {
-      override def name = absfile.name
-      override def path = absfile.path
-      override def jfile = Optional.ofNullable(absfile.file)
-    }
-
-  final class PlainClassBuilder(cunit: CompilationUnit) extends SyncAndTryBuilder(cunit)
-
-//  class BCodePhase() {
-
-  private var bytecodeWriter  : BytecodeWriter   = null
-  private var mirrorCodeGen   : JMirrorBuilder   = null
-
-  /* ---------------- q1 ---------------- */
-
-  case class Item1(arrivalPos: Int, cd: TypeDef, cunit: CompilationUnit) {
-    def isPoison: Boolean = { arrivalPos == Int.MaxValue }
-  }
-  private val poison1 = Item1(Int.MaxValue, null, ctx.compilationUnit)
-  private val q1 = new java.util.LinkedList[Item1]
-
-  /* ---------------- q2 ---------------- */
-
-  case class SubItem2(classNode: asm.tree.ClassNode,
-                      file:      dotty.tools.io.AbstractFile)
-
-  case class Item2(arrivalPos: Int,
-                    mirror:     SubItem2,
-                    plain:      SubItem2) {
-    def isPoison: Boolean = { arrivalPos == Int.MaxValue }
-  }
-
-  private val poison2 = Item2(Int.MaxValue, null, null)
-  private val q2 = new _root_.java.util.LinkedList[Item2]
-
-  /* ---------------- q3 ---------------- */
-
-  /*
-    *  An item of queue-3 (the last queue before serializing to disk) contains three of these
-    *  (one for each of mirror and plain classes).
-    *
-    *  @param jclassName  internal name of the class
-    *  @param jclassBytes bytecode emitted for the class SubItem3 represents
-    */
-  case class SubItem3(
-                        jclassName:  String,
-                        jclassBytes: Array[Byte],
-                        jclassFile:  dotty.tools.io.AbstractFile
-                        )
-
-  case class Item3(arrivalPos: Int,
-                    mirror:     SubItem3,
-                    plain:      SubItem3) {
-
-    def isPoison: Boolean  = { arrivalPos == Int.MaxValue }
-  }
-  private val i3comparator = new java.util.Comparator[Item3] {
-    override def compare(a: Item3, b: Item3) = {
-      if (a.arrivalPos < b.arrivalPos) -1
-      else if (a.arrivalPos == b.arrivalPos) 0
-      else 1
-    }
-  }
-  private val poison3 = Item3(Int.MaxValue, null, null)
-  private val q3 = new java.util.PriorityQueue[Item3](1000, i3comparator)
-
-  /*
-    *  Pipeline that takes ClassDefs from queue-1, lowers them into an intermediate form, placing them on queue-2
-    */
-  class Worker1(needsOutFolder: Boolean) {
-
-    private val lowerCaseNames = mutable.HashMap.empty[String, Symbol]
-    private def checkForCaseConflict(javaClassName: String, classSymbol: Symbol) = {
-      val lowerCaseName = javaClassName.toLowerCase
-      lowerCaseNames.get(lowerCaseName) match {
-        case None =>
-          lowerCaseNames.put(lowerCaseName, classSymbol)
-        case Some(dupClassSym) =>
-          // Order is not deterministic so we enforce lexicographic order between the duplicates for error-reporting
-          val (cl1, cl2) =
-            if (classSymbol.effectiveName.toString < dupClassSym.effectiveName.toString) (classSymbol, dupClassSym)
-            else (dupClassSym, classSymbol)
-          val same = classSymbol.effectiveName.toString == dupClassSym.effectiveName.toString
-          atPhase(typerPhase) {
-            if (same)
-              report.error(
-                em"$cl1 and ${cl2.showLocated} produce classes that overwrite one another", cl1.sourcePos)
-            else
-              report.warning(
-                em"""$cl1 differs only in case from ${cl2.showLocated}.
-                    |uch classes will overwrite one another on case-insensitive filesystems.""", cl1.sourcePos)
-          }
-      }
-    }
-
-    def run(): Unit = {
-      while (true) {
-        val item = q1.poll
-        if (item.isPoison) {
-          q2 add poison2
-          return
-        }
-        else {
-          try   { /*withCurrentUnit(item.cunit)*/(visit(item)) }
-          catch {
-            case ex: InterruptedException =>
-              throw ex
-            case ex: Throwable =>
-              println(s"Error while emitting ${item.cunit.source.file.name}")
-              throw ex
-          }
-        }
-      }
-    }
-
-    /*
-      *  Checks for duplicate internal names case-insensitively,
-      *  builds ASM ClassNodes for mirror and plain classes;
-      *  enqueues them in queue-2.
-      *
-      */
-    def visit(item: Item1): Boolean = {
-      val Item1(arrivalPos, cd, cunit) = item
-      val claszSymbol = cd.symbol
-
-      // -------------- mirror class, if needed --------------
-      val mirrorC =
-        if (claszSymbol.isTopLevelModuleClass) {
-          if (claszSymbol.companionClass == NoSymbol) {
-            mirrorCodeGen.genMirrorClass(claszSymbol, cunit)
-          } else {
-            report.log(s"No mirror class for module with linked class: ${claszSymbol.showFullName}")
-            null
-          }
-        } else null
-
-      // -------------- "plain" class --------------
-      val pcb = new PlainClassBuilder(cunit)
-      pcb.genPlainClass(cd)
-      val outF = if (needsOutFolder) getOutFolder(claszSymbol, pcb.thisName) else null;
-      val plainC = pcb.cnode
-
-      if (claszSymbol.isClass) // @DarkDimius is this test needed here?
-        for (binary <- ctx.compilationUnit.pickled.get(claszSymbol.asClass)) {
-          val store = if (mirrorC ne null) mirrorC else plainC
-          val tasty =
-            val outTastyFile = getFileForClassfile(outF, store.name, ".tasty")
-            val outstream = new DataOutputStream(outTastyFile.bufferedOutput)
-            try outstream.write(binary())
-            catch case ex: ClosedByInterruptException =>
-              try
-                outTastyFile.delete() // don't leave an empty or half-written tastyfile around after an interrupt
-              catch
-                case _: Throwable =>
-              throw ex
-            finally outstream.close()
-
-            val uuid = new TastyHeaderUnpickler(TastyUnpickler.scala3CompilerConfig, binary()).readHeader()
-            val lo = uuid.getMostSignificantBits
-            val hi = uuid.getLeastSignificantBits
-
-            // TASTY attribute is created but only the UUID bytes are stored in it.
-            // A TASTY attribute has length 16 if and only if the .tasty file exists.
-            val buffer = new TastyBuffer(16)
-            buffer.writeUncompressedLong(lo)
-            buffer.writeUncompressedLong(hi)
-            buffer.bytes
-
-          val dataAttr = createJAttribute(nme.TASTYATTR.mangledString, tasty, 0, tasty.length)
-          store.visitAttribute(dataAttr)
-        }
-
-
-      // ----------- create files
-
-      val classNodes = List(mirrorC, plainC)
-      val classFiles = classNodes.map(cls =>
-        if (outF != null && cls != null) {
-          try {
-            checkForCaseConflict(cls.name, claszSymbol)
-            getFileForClassfile(outF, cls.name, ".class")
-          } catch {
-            case e: FileConflictException =>
-              report.error(em"error writing ${cls.name}: ${e.getMessage}")
-              null
-          }
-        } else null
-      )
-
-      // ----------- compiler and sbt's callbacks
-
-      val (fullClassName, isLocal) = atPhase(sbtExtractDependenciesPhase) {
-        (ExtractDependencies.classNameAsString(claszSymbol), claszSymbol.isLocal)
-      }
-
-      for ((cls, clsFile) <- classNodes.zip(classFiles)) {
-        if (cls != null) {
-          val className = cls.name.replace('/', '.')
-          if (ctx.compilerCallback != null)
-            ctx.compilerCallback.onClassGenerated(sourceFile, convertAbstractFile(clsFile), className)
-          if (ctx.sbtCallback != null) {
-            if (isLocal)
-              ctx.sbtCallback.generatedLocalClass(sourceFile.jfile.orElse(null), clsFile.file)
-            else {
-              ctx.sbtCallback.generatedNonLocalClass(sourceFile.jfile.orElse(null), clsFile.file,
-                className, fullClassName)
-            }
-          }
-        }
-      }
-
-      // ----------- hand over to pipeline-2
-
-      val item2 =
-        Item2(arrivalPos,
-          SubItem2(mirrorC, classFiles(0)),
-          SubItem2(plainC, classFiles(1)))
-
-      q2 add item2 // at the very end of this method so that no Worker2 thread starts mutating before we're done.
-
-    } // end of method visit(Item1)
-
-  } // end of class BCodePhase.Worker1
-
-  /*
-    *  Pipeline that takes ClassNodes from queue-2. The unit of work depends on the optimization level:
-    *
-    *    (a) no optimization involves:
-    *          - converting the plain ClassNode to byte array and placing it on queue-3
-    */
-  class Worker2 {
-    import bTypes.ClassBType
-    import bTypes.coreBTypes.jliLambdaMetaFactoryAltMetafactoryHandle
-    // lazy val localOpt = new LocalOpt(new Settings())
-
-    private def localOptimizations(classNode: ClassNode): Unit = {
-      // BackendStats.timed(BackendStats.methodOptTimer)(localOpt.methodOptimizations(classNode))
-    }
-
-
-    /* Return an array of all serializable lambdas in this class */
-    private def collectSerializableLambdas(classNode: ClassNode): Array[Handle] = {
-      val indyLambdaBodyMethods = new mutable.ArrayBuffer[Handle]
-      for (m <- classNode.methods.asScala) {
-        val iter = m.instructions.iterator
-        while (iter.hasNext) {
-          val insn = iter.next()
-          insn match {
-            case indy: InvokeDynamicInsnNode
-              if indy.bsm == jliLambdaMetaFactoryAltMetafactoryHandle =>
-                import java.lang.invoke.LambdaMetafactory.FLAG_SERIALIZABLE
-                val metafactoryFlags = indy.bsmArgs(3).asInstanceOf[Integer].toInt
-                val isSerializable = (metafactoryFlags & FLAG_SERIALIZABLE) != 0
-                if isSerializable then
-                  val implMethod = indy.bsmArgs(1).asInstanceOf[Handle]
-                  indyLambdaBodyMethods += implMethod
-            case _ =>
-          }
-        }
-      }
-      indyLambdaBodyMethods.toArray
-    }
-
-    /*
-      * Add:
-      *
-      * private static Object $deserializeLambda$(SerializedLambda l) {
-      *   try return indy[scala.runtime.LambdaDeserialize.bootstrap, targetMethodGroup$0](l)
-      *   catch {
-      *     case i: IllegalArgumentException =>
-      *       try return indy[scala.runtime.LambdaDeserialize.bootstrap, targetMethodGroup$1](l)
-      *       catch {
-      *         case i: IllegalArgumentException =>
-      *           ...
-      *             return indy[scala.runtime.LambdaDeserialize.bootstrap, targetMethodGroup${NUM_GROUPS-1}](l)
-      *       }
-      *
-      * We use invokedynamic here to enable caching within the deserializer without needing to
-      * host a static field in the enclosing class. This allows us to add this method to interfaces
-      * that define lambdas in default methods.
-      *
-      * SI-10232 we can't pass arbitrary number of method handles to the final varargs parameter of the bootstrap
-      * method due to a limitation in the JVM. Instead, we emit a separate invokedynamic bytecode for each group of target
-      * methods.
-      */
-    private def addLambdaDeserialize(classNode: ClassNode, implMethodsArray: Array[Handle]): Unit = {
-      import asm.Opcodes._
-      import bTypes._
-      import coreBTypes._
-
-      val cw = classNode
-
-      // Make sure to reference the ClassBTypes of all types that are used in the code generated
-      // here (e.g. java/util/Map) are initialized. Initializing a ClassBType adds it to
-      // `classBTypeFromInternalNameMap`. When writing the classfile, the asm ClassWriter computes
-      // stack map frames and invokes the `getCommonSuperClass` method. This method expects all
-      // ClassBTypes mentioned in the source code to exist in the map.
-
-      val serlamObjDesc = MethodBType(jliSerializedLambdaRef :: Nil, ObjectRef).descriptor
-
-      val mv = cw.visitMethod(ACC_PRIVATE + ACC_STATIC + ACC_SYNTHETIC, "$deserializeLambda$", serlamObjDesc, null, null)
-      def emitLambdaDeserializeIndy(targetMethods: Seq[Handle]): Unit = {
-        mv.visitVarInsn(ALOAD, 0)
-        mv.visitInvokeDynamicInsn("lambdaDeserialize", serlamObjDesc, jliLambdaDeserializeBootstrapHandle, targetMethods: _*)
-      }
-
-      val targetMethodGroupLimit = 255 - 1 - 3 // JVM limit. See See MAX_MH_ARITY in CallSite.java
-      val groups: Array[Array[Handle]] = implMethodsArray.grouped(targetMethodGroupLimit).toArray
-      val numGroups = groups.length
-
-      import scala.tools.asm.Label
-      val initialLabels = Array.fill(numGroups - 1)(new Label())
-      val terminalLabel = new Label
-      def nextLabel(i: Int) = if (i == numGroups - 2) terminalLabel else initialLabels(i + 1)
-
-      for ((label, i) <- initialLabels.iterator.zipWithIndex) {
-        mv.visitTryCatchBlock(label, nextLabel(i), nextLabel(i), jlIllegalArgExceptionRef.internalName)
-      }
-      for ((label, i) <- initialLabels.iterator.zipWithIndex) {
-        mv.visitLabel(label)
-        emitLambdaDeserializeIndy(groups(i).toIndexedSeq)
-        mv.visitInsn(ARETURN)
-      }
-      mv.visitLabel(terminalLabel)
-      emitLambdaDeserializeIndy(groups(numGroups - 1).toIndexedSeq)
-      mv.visitInsn(ARETURN)
-    }
-
-    private def setInnerClasses(classNode: ClassNode): Unit = if (classNode != null) {
-      classNode.innerClasses.clear()
-      val (declared, referred) = collectNestedClasses(classNode)
-      addInnerClasses(classNode, declared, referred)
-    }
-
-    /**
-     * Visit the class node and collect all referenced nested classes.
-     */
-    private def collectNestedClasses(classNode: ClassNode): (List[ClassBType], List[ClassBType]) = {
-      // type InternalName = String
-      val c = new NestedClassesCollector[ClassBType](nestedOnly = true) {
-        def declaredNestedClasses(internalName: InternalName): List[ClassBType] =
-          bTypes.classBTypeFromInternalName(internalName).info.memberClasses
-
-        def getClassIfNested(internalName: InternalName): Option[ClassBType] = {
-          val c = bTypes.classBTypeFromInternalName(internalName)
-          Option.when(c.isNestedClass)(c)
-        }
-
-        def raiseError(msg: String, sig: String, e: Option[Throwable]): Unit = {
-          // don't crash on invalid generic signatures
-        }
-      }
-      c.visit(classNode)
-      (c.declaredInnerClasses.toList, c.referredInnerClasses.toList)
-    }
-
-    def run(): Unit = {
-      while (true) {
-        val item = q2.poll
-        if (item.isPoison) {
-          q3 add poison3
-          return
-        }
-        else {
-          try {
-            val plainNode = item.plain.classNode
-            localOptimizations(plainNode)
-            val serializableLambdas = collectSerializableLambdas(plainNode)
-            if (serializableLambdas.nonEmpty)
-              addLambdaDeserialize(plainNode, serializableLambdas)
-            setInnerClasses(plainNode)
-            setInnerClasses(item.mirror.classNode)
-            addToQ3(item)
-          } catch {
-            case ex: InterruptedException =>
-              throw ex
-            case ex: Throwable =>
-              println(s"Error while emitting ${item.plain.classNode.name}")
-              throw ex
-          }
-        }
-      }
-    }
-
-    private def addToQ3(item: Item2) = {
-
-      def getByteArray(cn: asm.tree.ClassNode): Array[Byte] = {
-        val cw = new CClassWriter(extraProc)
-        cn.accept(cw)
-        cw.toByteArray
-      }
-
-      val Item2(arrivalPos, SubItem2(mirror, mirrorFile), SubItem2(plain, plainFile)) = item
-
-      val mirrorC = if (mirror == null) null else SubItem3(mirror.name, getByteArray(mirror), mirrorFile)
-      val plainC  = SubItem3(plain.name, getByteArray(plain), plainFile)
-
-      if (AsmUtils.traceSerializedClassEnabled && plain.name.contains(AsmUtils.traceSerializedClassPattern)) {
-        if (mirrorC != null) AsmUtils.traceClass(mirrorC.jclassBytes)
-        AsmUtils.traceClass(plainC.jclassBytes)
-      }
-
-      q3 add Item3(arrivalPos, mirrorC, plainC)
-    }
-
-  } // end of class BCodePhase.Worker2
-
-  var arrivalPos: Int = 0
-
-  /*
-    *  A run of the BCodePhase phase comprises:
-    *
-    *    (a) set-up steps (most notably supporting maps in `BCodeTypes`,
-    *        but also "the" writer where class files in byte-array form go)
-    *
-    *    (b) building of ASM ClassNodes, their optimization and serialization.
-    *
-    *    (c) tear down (closing the classfile-writer and clearing maps)
-    *
-    */
-  def run(t: Tree)(using Context): Unit = {
-    this.tree = t
-
-    // val bcodeStart = Statistics.startTimer(BackendStats.bcodeTimer)
-
-    // val initStart = Statistics.startTimer(BackendStats.bcodeInitTimer)
-    arrivalPos = 0 // just in case
-    // scalaPrimitives.init()
-    bTypes.intializeCoreBTypes()
-    // Statistics.stopTimer(BackendStats.bcodeInitTimer, initStart)
-
-    // initBytecodeWriter invokes fullName, thus we have to run it before the typer-dependent thread is activated.
-    bytecodeWriter  = initBytecodeWriter()
-    mirrorCodeGen   = new JMirrorBuilder
-
-    val needsOutfileForSymbol = bytecodeWriter.isInstanceOf[ClassBytecodeWriter]
-    buildAndSendToDisk(needsOutfileForSymbol)
-
-    // closing output files.
-    bytecodeWriter.close()
-    // Statistics.stopTimer(BackendStats.bcodeTimer, bcodeStart)
-
-    if (ctx.compilerCallback != null)
-      ctx.compilerCallback.onSourceCompiled(sourceFile)
-
-    /* TODO Bytecode can be verified (now that all classfiles have been written to disk)
-      *
-      * (1) asm.util.CheckAdapter.verify()
-      *       public static void verify(ClassReader cr, ClassLoader loader, boolean dump, PrintWriter pw)
-      *     passing a custom ClassLoader to verify inter-dependent classes.
-      *     Alternatively,
-      *       - an offline-bytecode verifier could be used (e.g. Maxine brings one as separate tool).
-      *       - -Xverify:all
-      *
-      * (2) if requested, check-java-signatures, over and beyond the syntactic checks in `getGenericSignature()`
-      *
-      */
-  }
-
-  /*
-    *  Sequentially:
-    *    (a) place all ClassDefs in queue-1
-    *    (b) dequeue one at a time from queue-1, convert it to ASM ClassNode, place in queue-2
-    *    (c) dequeue one at a time from queue-2, convert it to byte-array,    place in queue-3
-    *    (d) serialize to disk by draining queue-3.
-    */
-  private def buildAndSendToDisk(needsOutFolder: Boolean)(using Context) = {
-    try
-      feedPipeline1()
-      // val genStart = Statistics.startTimer(BackendStats.bcodeGenStat)
-      (new Worker1(needsOutFolder)).run()
-      // Statistics.stopTimer(BackendStats.bcodeGenStat, genStart)
-
-      (new Worker2).run()
-
-      // val writeStart = Statistics.startTimer(BackendStats.bcodeWriteTimer)
-      drainQ3()
-      // Statistics.stopTimer(BackendStats.bcodeWriteTimer, writeStart)
-    catch
-      case e: MethodTooLargeException =>
-        val method =
-          s"${e.getClassName.replaceAll("/", ".")}.${e.getMethodName}"
-        val msg =
-          em"Generated bytecode for method '$method' is too large. Size: ${e.getCodeSize} bytes. Limit is 64KB"
-        report.error(msg)
-      case e: ClassTooLargeException =>
-        val msg =
-          em"Class '${e.getClassName.replaceAll("/", ".")}' is too large. Constant pool size: ${e.getConstantPoolCount}. Limit is 64K entries"
-        report.error(msg)
-
-  }
-
-  /* Feed pipeline-1: place all ClassDefs on q1, recording their arrival position. */
-  private def feedPipeline1() = {
-    def gen(tree: Tree): Unit = {
-      tree match {
-        case EmptyTree            => ()
-        case PackageDef(_, stats) => stats foreach gen
-        case ValDef(name, tpt, rhs) => () // module val not emitted
-        case cd: TypeDef         =>
-          q1 add Item1(arrivalPos, cd, int.ctx.compilationUnit)
-          arrivalPos += 1
-      }
-    }
-    gen(tree)
-    q1 add poison1
-  }
-
-  /* Pipeline that writes classfile representations to disk. */
-  private def drainQ3() = {
-
-    def sendToDisk(cfr: SubItem3): Unit = {
-      if (cfr != null){
-        val SubItem3(jclassName, jclassBytes, jclassFile) = cfr
-        bytecodeWriter.writeClass(jclassName, jclassName, jclassBytes, jclassFile)
-      }
-    }
-
-    var moreComing = true
-    // `expected` denotes the arrivalPos whose Item3 should be serialized next
-    var expected = 0
-
-    while (moreComing) {
-      val incoming = q3.poll
-      moreComing   = !incoming.isPoison
-      if (moreComing) {
-        val item = incoming
-        sendToDisk(item.mirror)
-        sendToDisk(item.plain)
-        expected += 1
-      }
-    }
-
-    // we're done
-    assert(q1.isEmpty, s"Some ClassDefs remained in the first queue: $q1")
-    assert(q2.isEmpty, s"Some classfiles remained in the second queue: $q2")
-    assert(q3.isEmpty, s"Some classfiles weren't written to disk: $q3")
-
-  }
-  //} // end of class BCodePhase
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/GenBCodeOps.scala b/tests/pos-with-compiler-cc/backend/jvm/GenBCodeOps.scala
deleted file mode 100644
index 210e47566cb9..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/GenBCodeOps.scala
+++ /dev/null
@@ -1,16 +0,0 @@
-package dotty.tools
-package backend
-package jvm
-
-import scala.tools.asm
-
-object GenBCodeOps extends GenBCodeOps
-
-class GenBCodeOps {
-  extension (flags: Int)
-    def addFlagIf(cond: Boolean, flag: Int): Int = if cond then flags | flag else flags
-
-  final val PublicStatic      = asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_STATIC
-  final val PublicStaticFinal = asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_STATIC | asm.Opcodes.ACC_FINAL
-  final val PrivateStaticFinal = asm.Opcodes.ACC_PRIVATE | asm.Opcodes.ACC_STATIC | asm.Opcodes.ACC_FINAL
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/GenericSignatureVisitor.scala b/tests/pos-with-compiler-cc/backend/jvm/GenericSignatureVisitor.scala
deleted file mode 100644
index e9e532933290..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/GenericSignatureVisitor.scala
+++ /dev/null
@@ -1,326 +0,0 @@
-package dotty.tools.backend.jvm
-
-import scala.language.unsafeNulls
-
-import scala.tools.asm.{ClassReader, Type, Handle }
-import scala.tools.asm.tree._
-
-import scala.collection.mutable
-import scala.util.control.{NoStackTrace, NonFatal}
-import scala.annotation._
-import scala.jdk.CollectionConverters._
-
-// Backported from scala/scala, commit sha: 724be0e9425b9ad07c244d25efdad695d75abbcf
-// https://github.com/scala/scala/blob/724be0e9425b9ad07c244d25efdad695d75abbcf/src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala#L928
-abstract class GenericSignatureVisitor(nestedOnly: Boolean) {
-  // For performance (`Char => Boolean` is not specialized)
-  private trait CharBooleanFunction { def apply(c: Char): Boolean }
-
-  final def visitInternalName(internalName: String): Unit = visitInternalName(internalName, 0, if (internalName eq null) 0 else internalName.length)
-  def visitInternalName(internalName: String, offset: Int, length: Int): Unit
-
-  def raiseError(msg: String, sig: String, e: Option[Throwable] = None): Unit
-
-  def visitClassSignature(sig: String): Unit = if (sig != null) {
-    val p = new Parser(sig, nestedOnly)
-    p.safely { p.classSignature() }
-  }
-
-  def visitMethodSignature(sig: String): Unit = if (sig != null) {
-    val p = new Parser(sig, nestedOnly)
-    p.safely { p.methodSignature() }
-  }
-
-  def visitFieldSignature(sig: String): Unit = if (sig != null) {
-    val p = new Parser(sig, nestedOnly)
-    p.safely { p.fieldSignature() }
-  }
-
-  private final class Parser(sig: String, nestedOnly: Boolean) {
-
-    private var index = 0
-    private val end = sig.length
-
-    private val Aborted: Throwable = new NoStackTrace { }
-    private def abort(): Nothing = throw Aborted
-
-    @inline def safely(f: => Unit): Unit = try f catch {
-      case Aborted =>
-      case NonFatal(e) => raiseError(s"Exception thrown during signature parsing", sig, Some(e))
-    }
-
-    private def current = {
-      if (index >= end) {
-        raiseError(s"Out of bounds, $index >= $end", sig)
-        abort() // Don't continue, even if `notifyInvalidSignature` returns
-      }
-      sig.charAt(index)
-    }
-
-    private def accept(c: Char): Unit = {
-      if (current != c) {
-        raiseError(s"Expected $c at $index, found $current", sig)
-        abort()
-      }
-      index += 1
-    }
-
-    private def skip(): Unit = { index += 1 }
-    private def getCurrentAndSkip(): Char = { val c = current; skip(); c }
-
-    private def skipUntil(isDelimiter: CharBooleanFunction): Unit = {
-      while (!isDelimiter(current)) { index += 1 }
-    }
-    private def skipUntilDelimiter(delimiter: Char): Unit = {
-      sig.indexOf(delimiter, index) match {
-        case -1 =>
-          raiseError(s"Out of bounds", sig)
-          abort() // Don't continue, even if `notifyInvalidSignature` returns
-        case i =>
-          index = i
-      }
-    }
-
-    private def appendUntil(builder: java.lang.StringBuilder, isDelimiter: CharBooleanFunction): Unit = {
-      val start = index
-      skipUntil(isDelimiter)
-      builder.append(sig, start, index)
-    }
-
-    def isBaseType(c: Char): Boolean = c match {
-      case 'B' | 'C' | 'D' | 'F' | 'I' | 'J' | 'S' | 'Z' => true
-      case _ => false
-    }
-
-    private val isClassNameEnd: CharBooleanFunction = (c: Char) => c == '<' || c == '.' || c == ';'
-
-    private def typeArguments(): Unit = if (current == '<') {
-      skip()
-      while (current != '>') current match {
-        case '*' | '+' | '-' =>
-          skip()
-        case _ =>
-          referenceTypeSignature()
-      }
-      accept('>')
-    }
-
-    @tailrec private def referenceTypeSignature(): Unit = getCurrentAndSkip() match {
-      case 'L' =>
-        var names: java.lang.StringBuilder = null
-
-        val start = index
-        var seenDollar = false
-        while (!isClassNameEnd(current)) {
-          seenDollar ||= current == '$'
-          index += 1
-        }
-        if ((current == '.' || seenDollar) || !nestedOnly) {
-          // OPT: avoid allocations when only a top-level class is encountered
-          names = new java.lang.StringBuilder(32)
-          names.append(sig, start, index)
-          visitInternalName(names.toString)
-        }
-        typeArguments()
-
-        while (current == '.') {
-          skip()
-          names.append('$')
-          appendUntil(names, isClassNameEnd)
-          visitInternalName(names.toString)
-          typeArguments()
-        }
-        accept(';')
-
-      case 'T' =>
-        skipUntilDelimiter(';')
-        skip()
-
-      case '[' =>
-        if (isBaseType(current)) skip()
-        else referenceTypeSignature()
-    }
-
-    private def typeParameters(): Unit = if (current == '<') {
-      skip()
-      while (current != '>') {
-        skipUntilDelimiter(':'); skip()
-        val c = current
-        // The ClassBound can be missing, but only if there's an InterfaceBound after.
-        // This is an assumption that's not in the spec, see https://stackoverflow.com/q/44284928
-        if (c != ':' && c != '>') { referenceTypeSignature() }
-        while (current == ':') { skip(); referenceTypeSignature() }
-      }
-      accept('>')
-    }
-
-    def classSignature(): Unit = {
-      typeParameters()
-      while (index < end) referenceTypeSignature()
-    }
-
-    def methodSignature(): Unit = {
-      typeParameters()
-
-      accept('(')
-      while (current != ')') {
-        if (isBaseType(current)) skip()
-        else referenceTypeSignature()
-      }
-      accept(')')
-
-      if (current == 'V' || isBaseType(current)) skip()
-      else referenceTypeSignature()
-
-      while (index < end) {
-        accept('^')
-        referenceTypeSignature()
-      }
-    }
-
-    def fieldSignature(): Unit = if (sig != null) safely {
-      referenceTypeSignature()
-    }
-  }
-}
-
-// Backported from scala/scala, commit sha: 724be0e9425b9ad07c244d25efdad695d75abbcf
-// https://github.com/scala/scala/blob/724be0e9425b9ad07c244d25efdad695d75abbcf/src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala#L790 
-abstract class NestedClassesCollector[T](nestedOnly: Boolean) extends GenericSignatureVisitor(nestedOnly) {
-  type InternalName = String 
-
-  def declaredNestedClasses(internalName: InternalName): List[T]
-  def getClassIfNested(internalName: InternalName): Option[T]
-  
-  val declaredInnerClasses = mutable.Set.empty[T]
-  val referredInnerClasses = mutable.Set.empty[T]
-
-  def innerClasses: collection.Set[T] = declaredInnerClasses ++ referredInnerClasses
-  def clear(): Unit = {
-    declaredInnerClasses.clear()
-    referredInnerClasses.clear()
-  }
-
-  def visit(classNode: ClassNode): Unit = {
-    visitInternalName(classNode.name)
-    declaredInnerClasses ++= declaredNestedClasses(classNode.name)
-
-    visitInternalName(classNode.superName)
-    classNode.interfaces.asScala foreach visitInternalName
-    visitInternalName(classNode.outerClass)
-
-    visitAnnotations(classNode.visibleAnnotations)
-    visitAnnotations(classNode.visibleTypeAnnotations)
-    visitAnnotations(classNode.invisibleAnnotations)
-    visitAnnotations(classNode.invisibleTypeAnnotations)
-
-    visitClassSignature(classNode.signature)
-
-    for (f <- classNode.fields.asScala) {
-      visitDescriptor(f.desc)
-      visitAnnotations(f.visibleAnnotations)
-      visitAnnotations(f.visibleTypeAnnotations)
-      visitAnnotations(f.invisibleAnnotations)
-      visitAnnotations(f.invisibleTypeAnnotations)
-      visitFieldSignature(f.signature)
-    }
-
-    for (m <- classNode.methods.asScala) {
-      visitDescriptor(m.desc)
-
-      visitAnnotations(m.visibleAnnotations)
-      visitAnnotations(m.visibleTypeAnnotations)
-      visitAnnotations(m.invisibleAnnotations)
-      visitAnnotations(m.invisibleTypeAnnotations)
-      visitAnnotationss(m.visibleParameterAnnotations)
-      visitAnnotationss(m.invisibleParameterAnnotations)
-      visitAnnotations(m.visibleLocalVariableAnnotations)
-      visitAnnotations(m.invisibleLocalVariableAnnotations)
-
-      m.exceptions.asScala foreach visitInternalName
-      for (tcb <- m.tryCatchBlocks.asScala) visitInternalName(tcb.`type`)
-
-      val iter = m.instructions.iterator
-      while (iter.hasNext) iter.next() match {
-        case ti: TypeInsnNode           => visitInternalNameOrArrayReference(ti.desc)
-        case fi: FieldInsnNode          => visitInternalNameOrArrayReference(fi.owner); visitDescriptor(fi.desc)
-        case mi: MethodInsnNode         => visitInternalNameOrArrayReference(mi.owner); visitDescriptor(mi.desc)
-        case id: InvokeDynamicInsnNode  => visitDescriptor(id.desc); visitHandle(id.bsm); id.bsmArgs foreach visitConstant
-        case ci: LdcInsnNode            => visitConstant(ci.cst)
-        case ma: MultiANewArrayInsnNode => visitDescriptor(ma.desc)
-        case _ =>
-      }
-
-      visitMethodSignature(m.signature)
-    }
-  }
-
-  private def containsChar(s: String, offset: Int, length: Int, char: Char): Boolean = {
-    val ix = s.indexOf(char, offset)
-    !(ix == -1 || ix >= offset + length)
-  }
-
-  def visitInternalName(internalName: String, offset: Int, length: Int): Unit = if (internalName != null && containsChar(internalName, offset, length, '$')) {
-    for (c <- getClassIfNested(internalName.substring(offset, length)))
-      if (!declaredInnerClasses.contains(c))
-        referredInnerClasses += c
-  }
-
-  // either an internal/Name or [[Linternal/Name; -- there are certain references in classfiles
-  // that are either an internal name (without the surrounding `L;`) or an array descriptor
-  // `[Linternal/Name;`.
-  def visitInternalNameOrArrayReference(ref: String): Unit = if (ref != null) {
-    val bracket = ref.lastIndexOf('[')
-    if (bracket == -1) visitInternalName(ref)
-    else if (ref.charAt(bracket + 1) == 'L') visitInternalName(ref, bracket + 2, ref.length - 1)
-  }
-
-  // we are only interested in the class references in the descriptor, so we can skip over
-  // primitives and the brackets of array descriptors
-  def visitDescriptor(desc: String): Unit = (desc.charAt(0): @switch) match {
-    case '(' =>
-      var i = 1
-      while (i < desc.length) {
-        if (desc.charAt(i) == 'L') {
-          val start = i + 1 // skip the L
-          var seenDollar = false
-          while ({val ch = desc.charAt(i); seenDollar ||= (ch == '$'); ch != ';'}) i += 1
-          if (seenDollar)
-            visitInternalName(desc, start, i)
-        }
-        // skips over '[', ')', primitives
-        i += 1
-      }
-
-    case 'L' =>
-      visitInternalName(desc, 1, desc.length - 1)
-
-    case '[' =>
-      visitInternalNameOrArrayReference(desc)
-
-    case _ => // skip over primitive types
-  }
-
-  def visitConstant(const: AnyRef): Unit = const match {
-    case t: Type => visitDescriptor(t.getDescriptor)
-    case _ =>
-  }
-
-  // in principle we could references to annotation types, as they only end up as strings in the
-  // constant pool, not as class references. however, the java compiler still includes nested
-  // annotation classes in the innerClass table, so we do the same. explained in detail in the
-  // large comment in class BTypes.
-  def visitAnnotation(annot: AnnotationNode): Unit = {
-    visitDescriptor(annot.desc)
-    if (annot.values != null) annot.values.asScala foreach visitConstant
-  }
-
-  def visitAnnotations(annots: java.util.List[_ <: AnnotationNode]) = if (annots != null) annots.asScala foreach visitAnnotation
-  def visitAnnotationss(annotss: Array[java.util.List[AnnotationNode]]) = if (annotss != null) annotss foreach visitAnnotations
-
-  def visitHandle(handle: Handle): Unit = {
-    visitInternalNameOrArrayReference(handle.getOwner)
-    visitDescriptor(handle.getDesc)
-  }
-}
-
diff --git a/tests/pos-with-compiler-cc/backend/jvm/LabelNode1.java b/tests/pos-with-compiler-cc/backend/jvm/LabelNode1.java
deleted file mode 100644
index cf91fe619f5d..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/LabelNode1.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * 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.backend.jvm;
-
-import scala.tools.asm.Label;
-import scala.tools.asm.tree.ClassNode;
-import scala.tools.asm.tree.LabelNode;
-
-/**
- * A subclass of {@link LabelNode} to add user-definable flags.
- */
-public class LabelNode1 extends LabelNode {
-    public LabelNode1() {
-    }
-
-    public LabelNode1(Label label) {
-        super(label);
-    }
-
-    public int flags;
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/MethodNode1.java b/tests/pos-with-compiler-cc/backend/jvm/MethodNode1.java
deleted file mode 100644
index bfa4401830ba..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/MethodNode1.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * 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.backend.jvm;
-
-import scala.tools.asm.Label;
-import scala.tools.asm.Opcodes;
-import scala.tools.asm.tree.LabelNode;
-import scala.tools.asm.tree.MethodNode;
-/**
- * A subclass of {@link MethodNode} to customize the representation of
- * label nodes with {@link LabelNode1}.
- */
-public class MethodNode1 extends MethodNode {
-    public MethodNode1(int api, int access, String name, String descriptor, String signature, String[] exceptions) {
-        super(api, access, name, descriptor, signature, exceptions);
-    }
-
-    public MethodNode1(int access, String name, String descriptor, String signature, String[] exceptions) {
-        this(Opcodes.ASM6, access, name, descriptor, signature, exceptions);
-    }
-
-    public MethodNode1(int api) {
-        super(api);
-    }
-
-    public MethodNode1() {
-        this(Opcodes.ASM6);
-    }
-
-    @Override
-    protected LabelNode getLabelNode(Label label) {
-        if (!(label.info instanceof LabelNode)) {
-            label.info = new LabelNode1(label);
-        }
-        return (LabelNode) label.info;
-    }
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/Primitives.scala b/tests/pos-with-compiler-cc/backend/jvm/Primitives.scala
deleted file mode 100644
index c9ddfeab24e1..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/Primitives.scala
+++ /dev/null
@@ -1,191 +0,0 @@
-package dotty.tools
-package backend
-package jvm
-
-import java.io.PrintWriter
-
-object Primitives {
-  /** This class represents a primitive operation. */
-  class Primitive {
-  }
-
-  /** This class represents a test operation. */
-  sealed abstract class TestOp {
-
-    /** Returns the negation of this operation. */
-    def negate(): TestOp
-
-    /** Returns a string representation of this operation. */
-    override def toString(): String
-
-    /** used only from GenASM */
-    def opcodeIF(): Int
-
-    /** used only from GenASM */
-    def opcodeIFICMP(): Int
-
-  }
-
-  /** An equality test */
-  case object EQ extends TestOp {
-    def negate() = NE
-    override def toString() = "EQ"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFEQ
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPEQ
-  }
-
-  /** A non-equality test */
-  case object NE extends TestOp {
-    def negate() = EQ
-    override def toString() = "NE"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFNE
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPNE
-  }
-
-  /** A less-than test */
-  case object LT extends TestOp {
-    def negate() = GE
-    override def toString() = "LT"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFLT
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPLT
-  }
-
-  /** A greater-than-or-equal test */
-  case object GE extends TestOp {
-    def negate() = LT
-    override def toString() = "GE"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFGE
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPGE
-  }
-
-  /** A less-than-or-equal test */
-  case object LE extends TestOp {
-    def negate() = GT
-    override def toString() = "LE"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFLE
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPLE
-  }
-
-  /** A greater-than test */
-  case object GT extends TestOp {
-    def negate() = LE
-    override def toString() = "GT"
-    override def opcodeIF()     = scala.tools.asm.Opcodes.IFGT
-    override def opcodeIFICMP() = scala.tools.asm.Opcodes.IF_ICMPGT
-  }
-
-  /** This class represents an arithmetic operation. */
-  class ArithmeticOp {
-
-    /** Returns a string representation of this operation. */
-    override def toString(): String = this match {
-      case ADD => "ADD"
-      case SUB => "SUB"
-      case MUL => "MUL"
-      case DIV => "DIV"
-      case REM => "REM"
-      case NOT => "NOT"
-      case _   => throw new RuntimeException("ArithmeticOp unknown case")
-    }
-  }
-
-  /** An arithmetic addition operation */
-  case object ADD extends ArithmeticOp
-
-  /** An arithmetic subtraction operation */
-  case object SUB extends ArithmeticOp
-
-  /** An arithmetic multiplication operation */
-  case object MUL extends ArithmeticOp
-
-  /** An arithmetic division operation */
-  case object DIV extends ArithmeticOp
-
-  /** An arithmetic remainder operation */
-  case object REM extends ArithmeticOp
-
-  /** Bitwise negation. */
-  case object NOT extends ArithmeticOp
-
-  /** This class represents a shift operation. */
-  class ShiftOp {
-
-    /** Returns a string representation of this operation. */
-    override def toString(): String = this match {
-      case LSL =>  "LSL"
-      case ASR =>  "ASR"
-      case LSR =>  "LSR"
-      case _  => throw new RuntimeException("ShitOp unknown case")
-    }
-  }
-
-  /** A logical shift to the left */
-  case object LSL extends ShiftOp
-
-  /** An arithmetic shift to the right */
-  case object ASR extends ShiftOp
-
-  /** A logical shift to the right */
-  case object LSR extends ShiftOp
-
-  /** This class represents a logical operation. */
-  class LogicalOp {
-
-    /** Returns a string representation of this operation. */
-    override def toString(): String = this match {
-      case AND => "AND"
-      case OR  => "OR"
-      case XOR => "XOR"
-      case _  => throw new RuntimeException("LogicalOp unknown case")
-    }
-  }
-
-  /** A bitwise AND operation */
-  case object AND extends LogicalOp
-
-  /** A bitwise OR operation */
-  case object OR extends LogicalOp
-
-  /** A bitwise XOR operation */
-  case object XOR extends LogicalOp
-
-  /** Signals the beginning of a series of concatenations.
-    *  On the JVM platform, it should create a new StringBuffer
-    */
-  case object StartConcat extends Primitive
-
-  /**
-   * type: (buf) => STR
-   * jvm : It should turn the StringBuffer into a String.
-   */
-  case object EndConcat extends Primitive
-
-  /** Pretty printer for primitives */
-  class PrimitivePrinter(out: PrintWriter) {
-    def print(s: String): PrimitivePrinter = {
-      out.print(s)
-      this
-    }
-  }
-
-  /** This class represents a comparison operation. */
-  class ComparisonOp {
-
-    /** Returns a string representation of this operation. */
-    override def toString(): String = this match {
-      case CMPL => "CMPL"
-      case CMP  => "CMP"
-      case CMPG => "CMPG"
-      case _ => throw new RuntimeException("ComparisonOp unknown case")
-    }
-  }
-
-  /** A comparison operation with -1 default for NaNs */
-  case object CMPL extends ComparisonOp
-
-  /** A comparison operation with no default for NaNs */
-  case object CMP extends ComparisonOp
-
-  /** A comparison operation with +1 default for NaNs */
-  case object CMPG extends ComparisonOp
-}
diff --git a/tests/pos-with-compiler-cc/backend/jvm/scalaPrimitives.scala b/tests/pos-with-compiler-cc/backend/jvm/scalaPrimitives.scala
deleted file mode 100644
index 420ff7b20423..000000000000
--- a/tests/pos-with-compiler-cc/backend/jvm/scalaPrimitives.scala
+++ /dev/null
@@ -1,412 +0,0 @@
-package dotty.tools
-package backend.jvm
-
-import dotc.ast.Trees.Select
-import dotc.ast.tpd._
-import dotc.core._
-import Contexts._
-import Names.TermName, StdNames._
-import Types.{JavaArrayType, UnspecifiedErrorType, Type}
-import Symbols.{Symbol, NoSymbol}
-import Decorators.em
-import dotc.report
-import dotc.util.ReadOnlyMap
-
-import scala.annotation.threadUnsafe
-
-/** Scala primitive operations are represented as methods in `Any` and
- *  `AnyVal` subclasses. Here we demultiplex them by providing a mapping
- *  from their symbols to integers. Different methods exist for
- *  different value types, but with the same meaning (like plus, minus,
- *  etc.). They will all be mapped to the same int.
- *
- *  Note: The three equal methods have the following semantics:
- *  - `"=="` checks for `null`, and if non-null, calls
- *    `java.lang.Object.equals`
- *    `(class: Any; modifier: final)`. Primitive: `EQ`
- *  - `"eq"` usual reference comparison
- *    `(class: AnyRef; modifier: final)`. Primitive: `ID`
- *  - `"equals"` user-defined equality (Java semantics)
- *    `(class: Object; modifier: none)`. Primitive: `EQUALS`
- *
- * Inspired from the `scalac` compiler.
- */
-class DottyPrimitives(ictx: DetachedContext) {
-  import dotty.tools.backend.ScalaPrimitivesOps._
-
-  @threadUnsafe private lazy val primitives: ReadOnlyMap[Symbol, Int] = init
-
-  /** Return the code for the given symbol. */
-  def getPrimitive(sym: Symbol): Int = {
-    primitives(sym)
-  }
-
-  /**
-   * Return the primitive code of the given operation. If the
-   * operation is an array get/set, we inspect the type of the receiver
-   * to demux the operation.
-   *
-   * @param fun The method symbol
-   * @param tpe The type of the receiver object. It is used only for array
-   *            operations
-   */
-  def getPrimitive(app: Apply, tpe: Type)(using Context): Int = {
-    val fun = app.fun.symbol
-    val defn = ctx.definitions
-    val code = app.fun match {
-      case Select(_, nme.primitive.arrayLength) =>
-        LENGTH
-      case Select(_, nme.primitive.arrayUpdate) =>
-        UPDATE
-      case Select(_, nme.primitive.arrayApply) =>
-        APPLY
-      case _ => getPrimitive(fun)
-    }
-
-    def elementType: Type = tpe.widenDealias match {
-      case defn.ArrayOf(el) => el
-      case JavaArrayType(el) => el
-      case _ =>
-        report.error(em"expected Array $tpe")
-        UnspecifiedErrorType
-    }
-
-    code match {
-
-      case APPLY =>
-        defn.scalaClassName(elementType) match {
-          case tpnme.Boolean    => ZARRAY_GET
-          case tpnme.Byte       => BARRAY_GET
-          case tpnme.Short      => SARRAY_GET
-          case tpnme.Char       => CARRAY_GET
-          case tpnme.Int        => IARRAY_GET
-          case tpnme.Long       => LARRAY_GET
-          case tpnme.Float      => FARRAY_GET
-          case tpnme.Double     => DARRAY_GET
-          case _                => OARRAY_GET
-        }
-
-      case UPDATE =>
-        defn.scalaClassName(elementType) match {
-          case tpnme.Boolean    => ZARRAY_SET
-          case tpnme.Byte       => BARRAY_SET
-          case tpnme.Short      => SARRAY_SET
-          case tpnme.Char       => CARRAY_SET
-          case tpnme.Int        => IARRAY_SET
-          case tpnme.Long       => LARRAY_SET
-          case tpnme.Float      => FARRAY_SET
-          case tpnme.Double     => DARRAY_SET
-          case _                => OARRAY_SET
-        }
-
-      case LENGTH =>
-        defn.scalaClassName(elementType) match {
-          case tpnme.Boolean    => ZARRAY_LENGTH
-          case tpnme.Byte       => BARRAY_LENGTH
-          case tpnme.Short      => SARRAY_LENGTH
-          case tpnme.Char       => CARRAY_LENGTH
-          case tpnme.Int        => IARRAY_LENGTH
-          case tpnme.Long       => LARRAY_LENGTH
-          case tpnme.Float      => FARRAY_LENGTH
-          case tpnme.Double     => DARRAY_LENGTH
-          case _                => OARRAY_LENGTH
-        }
-
-      case _ =>
-        code
-    }
-  }
-
-  /** Initialize the primitive map */
-  private def init: ReadOnlyMap[Symbol, Int]  = {
-
-    given Context = ictx
-
-    import Symbols.defn
-    val primitives = Symbols.MutableSymbolMap[Int](512)
-
-    /** Add a primitive operation to the map */
-    def addPrimitive(s: Symbol, code: Int): Unit = {
-      assert(!(primitives contains s), "Duplicate primitive " + s)
-      primitives(s) = code
-    }
-
-    def addPrimitives(cls: Symbol, method: TermName, code: Int)(using Context): Unit = {
-      val alts = cls.info.member(method).alternatives.map(_.symbol)
-      if (alts.isEmpty)
-        report.error(em"Unknown primitive method $cls.$method")
-      else alts foreach (s =>
-        addPrimitive(s,
-          s.info.paramInfoss match {
-            case List(tp :: _) if code == ADD && tp =:= ctx.definitions.StringType => CONCAT
-            case _                                          => code
-          }
-        )
-        )
-    }
-
-    // scala.Any
-    addPrimitive(defn.Any_==, EQ)
-    addPrimitive(defn.Any_!=, NE)
-    addPrimitive(defn.Any_isInstanceOf, IS)
-    addPrimitive(defn.Any_asInstanceOf, AS)
-    addPrimitive(defn.Any_##, HASH)
-
-    // java.lang.Object
-    addPrimitive(defn.Object_eq, ID)
-    addPrimitive(defn.Object_ne, NI)
- /*   addPrimitive(defn.Any_==, EQ)
-    addPrimitive(defn.Any_!=, NE)*/
-    addPrimitive(defn.Object_synchronized, SYNCHRONIZED)
-    /*addPrimitive(defn.Any_isInstanceOf, IS)
-    addPrimitive(defn.Any_asInstanceOf, AS)*/
-
-    // java.lang.String
-    addPrimitive(defn.String_+, CONCAT)
-
-    // scala.Array
-    lazy val ArrayClass = defn.ArrayClass
-    addPrimitives(ArrayClass, nme.length, LENGTH)
-    addPrimitives(ArrayClass, nme.apply, APPLY)
-    addPrimitives(ArrayClass, nme.update, UPDATE)
-
-    // scala.Boolean
-    lazy val BooleanClass = defn.BooleanClass
-    addPrimitives(BooleanClass, nme.EQ, EQ)
-    addPrimitives(BooleanClass, nme.NE, NE)
-    addPrimitives(BooleanClass, nme.UNARY_!, ZNOT)
-    addPrimitives(BooleanClass, nme.ZOR, ZOR)
-    addPrimitives(BooleanClass, nme.ZAND, ZAND)
-    addPrimitives(BooleanClass, nme.OR, OR)
-    addPrimitives(BooleanClass, nme.AND, AND)
-    addPrimitives(BooleanClass, nme.XOR, XOR)
-
-    // scala.Byte
-    lazy val ByteClass = defn.ByteClass
-    addPrimitives(ByteClass, nme.EQ, EQ)
-    addPrimitives(ByteClass, nme.NE, NE)
-    addPrimitives(ByteClass, nme.ADD, ADD)
-    addPrimitives(ByteClass, nme.SUB, SUB)
-    addPrimitives(ByteClass, nme.MUL, MUL)
-    addPrimitives(ByteClass, nme.DIV, DIV)
-    addPrimitives(ByteClass, nme.MOD, MOD)
-    addPrimitives(ByteClass, nme.LT, LT)
-    addPrimitives(ByteClass, nme.LE, LE)
-    addPrimitives(ByteClass, nme.GT, GT)
-    addPrimitives(ByteClass, nme.GE, GE)
-    addPrimitives(ByteClass, nme.XOR, XOR)
-    addPrimitives(ByteClass, nme.OR, OR)
-    addPrimitives(ByteClass, nme.AND, AND)
-    addPrimitives(ByteClass, nme.LSL, LSL)
-    addPrimitives(ByteClass, nme.LSR, LSR)
-    addPrimitives(ByteClass, nme.ASR, ASR)
-      // conversions
-    addPrimitives(ByteClass, nme.toByte,   B2B)
-    addPrimitives(ByteClass, nme.toShort,  B2S)
-    addPrimitives(ByteClass, nme.toChar,   B2C)
-    addPrimitives(ByteClass, nme.toInt,    B2I)
-    addPrimitives(ByteClass, nme.toLong,   B2L)
-    // unary methods
-    addPrimitives(ByteClass, nme.UNARY_+, POS)
-    addPrimitives(ByteClass, nme.UNARY_-, NEG)
-    addPrimitives(ByteClass, nme.UNARY_~, NOT)
-
-    addPrimitives(ByteClass, nme.toFloat,  B2F)
-    addPrimitives(ByteClass, nme.toDouble, B2D)
-
-    // scala.Short
-    lazy val ShortClass = defn.ShortClass
-    addPrimitives(ShortClass, nme.EQ, EQ)
-    addPrimitives(ShortClass, nme.NE, NE)
-    addPrimitives(ShortClass, nme.ADD, ADD)
-    addPrimitives(ShortClass, nme.SUB, SUB)
-    addPrimitives(ShortClass, nme.MUL, MUL)
-    addPrimitives(ShortClass, nme.DIV, DIV)
-    addPrimitives(ShortClass, nme.MOD, MOD)
-    addPrimitives(ShortClass, nme.LT, LT)
-    addPrimitives(ShortClass, nme.LE, LE)
-    addPrimitives(ShortClass, nme.GT, GT)
-    addPrimitives(ShortClass, nme.GE, GE)
-    addPrimitives(ShortClass, nme.XOR, XOR)
-    addPrimitives(ShortClass, nme.OR, OR)
-    addPrimitives(ShortClass, nme.AND, AND)
-    addPrimitives(ShortClass, nme.LSL, LSL)
-    addPrimitives(ShortClass, nme.LSR, LSR)
-    addPrimitives(ShortClass, nme.ASR, ASR)
-      // conversions
-    addPrimitives(ShortClass, nme.toByte,   S2B)
-    addPrimitives(ShortClass, nme.toShort,  S2S)
-    addPrimitives(ShortClass, nme.toChar,   S2C)
-    addPrimitives(ShortClass, nme.toInt,    S2I)
-    addPrimitives(ShortClass, nme.toLong,   S2L)
-    // unary methods
-    addPrimitives(ShortClass, nme.UNARY_+, POS)
-    addPrimitives(ShortClass, nme.UNARY_-, NEG)
-    addPrimitives(ShortClass, nme.UNARY_~, NOT)
-
-    addPrimitives(ShortClass, nme.toFloat,  S2F)
-    addPrimitives(ShortClass, nme.toDouble, S2D)
-
-    // scala.Char
-    lazy val CharClass = defn.CharClass
-    addPrimitives(CharClass, nme.EQ, EQ)
-    addPrimitives(CharClass, nme.NE, NE)
-    addPrimitives(CharClass, nme.ADD, ADD)
-    addPrimitives(CharClass, nme.SUB, SUB)
-    addPrimitives(CharClass, nme.MUL, MUL)
-    addPrimitives(CharClass, nme.DIV, DIV)
-    addPrimitives(CharClass, nme.MOD, MOD)
-    addPrimitives(CharClass, nme.LT, LT)
-    addPrimitives(CharClass, nme.LE, LE)
-    addPrimitives(CharClass, nme.GT, GT)
-    addPrimitives(CharClass, nme.GE, GE)
-    addPrimitives(CharClass, nme.XOR, XOR)
-    addPrimitives(CharClass, nme.OR, OR)
-    addPrimitives(CharClass, nme.AND, AND)
-    addPrimitives(CharClass, nme.LSL, LSL)
-    addPrimitives(CharClass, nme.LSR, LSR)
-    addPrimitives(CharClass, nme.ASR, ASR)
-      // conversions
-    addPrimitives(CharClass, nme.toByte,   C2B)
-    addPrimitives(CharClass, nme.toShort,  C2S)
-    addPrimitives(CharClass, nme.toChar,   C2C)
-    addPrimitives(CharClass, nme.toInt,    C2I)
-    addPrimitives(CharClass, nme.toLong,   C2L)
-    // unary methods
-    addPrimitives(CharClass, nme.UNARY_+, POS)
-    addPrimitives(CharClass, nme.UNARY_-, NEG)
-    addPrimitives(CharClass, nme.UNARY_~, NOT)
-    addPrimitives(CharClass, nme.toFloat,  C2F)
-    addPrimitives(CharClass, nme.toDouble, C2D)
-
-    // scala.Int
-    lazy val IntClass = defn.IntClass
-    addPrimitives(IntClass, nme.EQ, EQ)
-    addPrimitives(IntClass, nme.NE, NE)
-    addPrimitives(IntClass, nme.ADD, ADD)
-    addPrimitives(IntClass, nme.SUB, SUB)
-    addPrimitives(IntClass, nme.MUL, MUL)
-    addPrimitives(IntClass, nme.DIV, DIV)
-    addPrimitives(IntClass, nme.MOD, MOD)
-    addPrimitives(IntClass, nme.LT, LT)
-    addPrimitives(IntClass, nme.LE, LE)
-    addPrimitives(IntClass, nme.GT, GT)
-    addPrimitives(IntClass, nme.GE, GE)
-    addPrimitives(IntClass, nme.XOR, XOR)
-    addPrimitives(IntClass, nme.OR, OR)
-    addPrimitives(IntClass, nme.AND, AND)
-    addPrimitives(IntClass, nme.LSL, LSL)
-    addPrimitives(IntClass, nme.LSR, LSR)
-    addPrimitives(IntClass, nme.ASR, ASR)
-      // conversions
-    addPrimitives(IntClass, nme.toByte,   I2B)
-    addPrimitives(IntClass, nme.toShort,  I2S)
-    addPrimitives(IntClass, nme.toChar,   I2C)
-    addPrimitives(IntClass, nme.toInt,    I2I)
-    addPrimitives(IntClass, nme.toLong,   I2L)
-    // unary methods
-    addPrimitives(IntClass, nme.UNARY_+, POS)
-    addPrimitives(IntClass, nme.UNARY_-, NEG)
-    addPrimitives(IntClass, nme.UNARY_~, NOT)
-    addPrimitives(IntClass, nme.toFloat,  I2F)
-    addPrimitives(IntClass, nme.toDouble, I2D)
-
-    // scala.Long
-    lazy val LongClass = defn.LongClass
-    addPrimitives(LongClass, nme.EQ, EQ)
-    addPrimitives(LongClass, nme.NE, NE)
-    addPrimitives(LongClass, nme.ADD, ADD)
-    addPrimitives(LongClass, nme.SUB, SUB)
-    addPrimitives(LongClass, nme.MUL, MUL)
-    addPrimitives(LongClass, nme.DIV, DIV)
-    addPrimitives(LongClass, nme.MOD, MOD)
-    addPrimitives(LongClass, nme.LT, LT)
-    addPrimitives(LongClass, nme.LE, LE)
-    addPrimitives(LongClass, nme.GT, GT)
-    addPrimitives(LongClass, nme.GE, GE)
-    addPrimitives(LongClass, nme.XOR, XOR)
-    addPrimitives(LongClass, nme.OR, OR)
-    addPrimitives(LongClass, nme.AND, AND)
-    addPrimitives(LongClass, nme.LSL, LSL)
-    addPrimitives(LongClass, nme.LSR, LSR)
-    addPrimitives(LongClass, nme.ASR, ASR)
-      // conversions
-    addPrimitives(LongClass, nme.toByte,   L2B)
-    addPrimitives(LongClass, nme.toShort,  L2S)
-    addPrimitives(LongClass, nme.toChar,   L2C)
-    addPrimitives(LongClass, nme.toInt,    L2I)
-    addPrimitives(LongClass, nme.toLong,   L2L)
-    // unary methods
-    addPrimitives(LongClass, nme.UNARY_+, POS)
-    addPrimitives(LongClass, nme.UNARY_-, NEG)
-    addPrimitives(LongClass, nme.UNARY_~, NOT)
-    addPrimitives(LongClass, nme.toFloat,  L2F)
-    addPrimitives(LongClass, nme.toDouble, L2D)
-
-    // scala.Float
-    lazy val FloatClass = defn.FloatClass
-    addPrimitives(FloatClass, nme.EQ, EQ)
-    addPrimitives(FloatClass, nme.NE, NE)
-    addPrimitives(FloatClass, nme.ADD, ADD)
-    addPrimitives(FloatClass, nme.SUB, SUB)
-    addPrimitives(FloatClass, nme.MUL, MUL)
-    addPrimitives(FloatClass, nme.DIV, DIV)
-    addPrimitives(FloatClass, nme.MOD, MOD)
-    addPrimitives(FloatClass, nme.LT, LT)
-    addPrimitives(FloatClass, nme.LE, LE)
-    addPrimitives(FloatClass, nme.GT, GT)
-    addPrimitives(FloatClass, nme.GE, GE)
-    // conversions
-    addPrimitives(FloatClass, nme.toByte,   F2B)
-    addPrimitives(FloatClass, nme.toShort,  F2S)
-    addPrimitives(FloatClass, nme.toChar,   F2C)
-    addPrimitives(FloatClass, nme.toInt,    F2I)
-    addPrimitives(FloatClass, nme.toLong,   F2L)
-    addPrimitives(FloatClass, nme.toFloat,  F2F)
-    addPrimitives(FloatClass, nme.toDouble, F2D)
-    // unary methods
-    addPrimitives(FloatClass, nme.UNARY_+, POS)
-    addPrimitives(FloatClass, nme.UNARY_-, NEG)
-
-    // scala.Double
-    lazy val DoubleClass = defn.DoubleClass
-    addPrimitives(DoubleClass, nme.EQ, EQ)
-    addPrimitives(DoubleClass, nme.NE, NE)
-    addPrimitives(DoubleClass, nme.ADD, ADD)
-    addPrimitives(DoubleClass, nme.SUB, SUB)
-    addPrimitives(DoubleClass, nme.MUL, MUL)
-    addPrimitives(DoubleClass, nme.DIV, DIV)
-    addPrimitives(DoubleClass, nme.MOD, MOD)
-    addPrimitives(DoubleClass, nme.LT, LT)
-    addPrimitives(DoubleClass, nme.LE, LE)
-    addPrimitives(DoubleClass, nme.GT, GT)
-    addPrimitives(DoubleClass, nme.GE, GE)
-    // conversions
-    addPrimitives(DoubleClass, nme.toByte,   D2B)
-    addPrimitives(DoubleClass, nme.toShort,  D2S)
-    addPrimitives(DoubleClass, nme.toChar,   D2C)
-    addPrimitives(DoubleClass, nme.toInt,    D2I)
-    addPrimitives(DoubleClass, nme.toLong,   D2L)
-    addPrimitives(DoubleClass, nme.toFloat,  D2F)
-    addPrimitives(DoubleClass, nme.toDouble, D2D)
-    // unary methods
-    addPrimitives(DoubleClass, nme.UNARY_+, POS)
-    addPrimitives(DoubleClass, nme.UNARY_-, NEG)
-
-
-    primitives
-  }
-
-  def isPrimitive(sym: Symbol): Boolean =
-    primitives.contains(sym)
-
-  def isPrimitive(fun: Tree): Boolean =
-    given Context = ictx
-    primitives.contains(fun.symbol)
-    || (fun.symbol == NoSymbol // the only trees that do not have a symbol assigned are array.{update,select,length,clone}}
-        && {
-          fun match
-            case Select(_, StdNames.nme.clone_) => false // but array.clone is NOT a primitive op.
-            case _ => true
-        })
-}
diff --git a/tests/pos-with-compiler-cc/backend/sjs/GenSJSIR.scala b/tests/pos-with-compiler-cc/backend/sjs/GenSJSIR.scala
deleted file mode 100644
index 1579b4577933..000000000000
--- a/tests/pos-with-compiler-cc/backend/sjs/GenSJSIR.scala
+++ /dev/null
@@ -1,23 +0,0 @@
-package dotty.tools.backend.sjs
-
-import dotty.tools.dotc.core._
-import Contexts._
-import Phases._
-
-/** Generates Scala.js IR files for the compilation unit. */
-class GenSJSIR extends Phase {
-
-  override def phaseName: String = GenSJSIR.name
-
-  override def description: String = GenSJSIR.description
-
-  override def isRunnable(using Context): Boolean =
-    super.isRunnable && ctx.settings.scalajs.value
-
-  def run(using Context): Unit =
-    new JSCodeGen().run()
-}
-
-object GenSJSIR:
-  val name: String = "genSJSIR"
-  val description: String = "generate .sjsir files for Scala.js"
diff --git a/tests/pos-with-compiler-cc/backend/sjs/JSCodeGen.scala b/tests/pos-with-compiler-cc/backend/sjs/JSCodeGen.scala
deleted file mode 100644
index 81f09b082850..000000000000
--- a/tests/pos-with-compiler-cc/backend/sjs/JSCodeGen.scala
+++ /dev/null
@@ -1,4897 +0,0 @@
-package dotty.tools.backend.sjs
-
-import scala.language.unsafeNulls
-
-import scala.annotation.switch
-import scala.collection.mutable
-
-import dotty.tools.FatalError
-import dotty.tools.dotc.CompilationUnit
-import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.core._
-import Contexts._
-import Decorators._
-import Flags._
-import Names._
-import NameKinds.DefaultGetterName
-import Types._
-import Symbols._
-import Phases._
-import StdNames._
-import TypeErasure.ErasedValueType
-
-import dotty.tools.dotc.transform.{Erasure, ValueClasses}
-import dotty.tools.dotc.transform.SymUtils._
-import dotty.tools.dotc.util.SourcePosition
-import dotty.tools.dotc.report
-
-import dotty.tools.sjs.ir
-import dotty.tools.sjs.ir.{ClassKind, Position, Names => jsNames, Trees => js, Types => jstpe}
-import dotty.tools.sjs.ir.Names.{ClassName, MethodName, SimpleMethodName}
-import dotty.tools.sjs.ir.OriginalName
-import dotty.tools.sjs.ir.OriginalName.NoOriginalName
-import dotty.tools.sjs.ir.Trees.OptimizerHints
-
-import dotty.tools.dotc.transform.sjs.JSSymUtils._
-
-import JSEncoding._
-import ScopedVar.withScopedVars
-import annotation.retains
-
-/** Main codegen for Scala.js IR.
- *
- *  [[GenSJSIR]] creates one instance of `JSCodeGen` per compilation unit.
- *  The `run()` method processes the whole compilation unit and generates
- *  `.sjsir` files for it.
- *
- *  There are 4 main levels of translation:
- *
- *  - `genCompilationUnit()` iterates through all the type definitions in the
- *    compilation unit. Each generated `js.ClassDef` is serialized to an
- *    `.sjsir` file.
- *  - `genScalaClass()` and other similar methods generate the skeleton of
- *    classes.
- *  - `genMethod()` and similar methods generate the declarations of methods.
- *  - `genStatOrExpr()` and everything else generate the bodies of methods.
- */
-class JSCodeGen()(using genCtx: DetachedContext) {
-  import JSCodeGen._
-  import tpd._
-
-  val sjsPlatform = dotty.tools.dotc.config.SJSPlatform.sjsPlatform
-  val jsdefn = JSDefinitions.jsdefn
-  private val primitives = new JSPrimitives(genCtx)
-
-  val positionConversions = new JSPositions()(using genCtx)
-  import positionConversions._
-
-  private val jsExportsGen = new JSExportsGen(this)
-
-  // Some state --------------------------------------------------------------
-
-  private val lazilyGeneratedAnonClasses = new MutableSymbolMap[TypeDef]
-  private val generatedClasses = mutable.ListBuffer.empty[js.ClassDef]
-  private val generatedStaticForwarderClasses = mutable.ListBuffer.empty[(Symbol, js.ClassDef)]
-
-  val currentClassSym: ScopedVar[Symbol] = new ScopedVar[Symbol]
-  private val currentMethodSym = new ScopedVar[Symbol]
-  private val localNames = new ScopedVar[LocalNameGenerator]
-  private val thisLocalVarIdent = new ScopedVar[Option[js.LocalIdent]]
-  private val isModuleInitialized = new ScopedVar[ScopedVar.VarBox[Boolean]]
-  private val undefinedDefaultParams = new ScopedVar[mutable.Set[Symbol]]
-
-  /* Contextual JS class value for some operations of nested JS classes that need one. */
-  private val contextualJSClassValue = new ScopedVar[Option[js.Tree]](None)
-
-  /** Resets all of the scoped state in the context of `body`. */
-  private def resetAllScopedVars[T](body: => T): T = {
-    withScopedVars(
-        currentClassSym := null,
-        currentMethodSym := null,
-        localNames := null,
-        thisLocalVarIdent := null,
-        isModuleInitialized := null,
-        undefinedDefaultParams := null
-    ) {
-      body
-    }
-  }
-
-  private def withPerMethodBodyState[A](methodSym: Symbol)(body: => A): A = {
-    withScopedVars(
-        currentMethodSym := methodSym,
-        thisLocalVarIdent := None,
-        isModuleInitialized := new ScopedVar.VarBox(false),
-        undefinedDefaultParams := mutable.Set.empty,
-    ) {
-      body
-    }
-  }
-
-  private def acquireContextualJSClassValue[A](f: Option[js.Tree] => A): A = {
-    val jsClassValue = contextualJSClassValue.get
-    withScopedVars(
-        contextualJSClassValue := None
-    ) {
-      f(jsClassValue)
-    }
-  }
-
-  def withNewLocalNameScope[A](body: => A): A = {
-    withScopedVars(localNames := new LocalNameGenerator) {
-      body
-    }
-  }
-
-  /** Implicitly materializes the current local name generator. */
-  implicit def implicitLocalNames: LocalNameGenerator = localNames.get
-
-  def currentThisType: jstpe.Type = {
-    encodeClassType(currentClassSym) match {
-      case tpe @ jstpe.ClassType(cls) =>
-        jstpe.BoxedClassToPrimType.getOrElse(cls, tpe)
-      case tpe =>
-        tpe
-    }
-  }
-
-  /** Returns a new fresh local identifier. */
-  private def freshLocalIdent()(implicit pos: Position): js.LocalIdent =
-    localNames.get.freshLocalIdent()
-
-  /** Returns a new fresh local identifier. */
-  def freshLocalIdent(base: String)(implicit pos: Position): js.LocalIdent =
-    localNames.get.freshLocalIdent(base)
-
-  /** Returns a new fresh local identifier. */
-  private def freshLocalIdent(base: TermName)(implicit pos: Position): js.LocalIdent =
-    localNames.get.freshLocalIdent(base)
-
-  private def consumeLazilyGeneratedAnonClass(sym: Symbol): TypeDef = {
-    val typeDef = lazilyGeneratedAnonClasses.remove(sym)
-    if (typeDef == null) {
-      throw new FatalError(
-          i"Could not find tree for lazily generated anonymous class ${sym.fullName} at ${sym.sourcePos}")
-    } else {
-      typeDef
-    }
-  }
-
-  // Compilation unit --------------------------------------------------------
-
-  def run(): Unit = {
-    try {
-      genCompilationUnit(ctx.compilationUnit)
-    } finally {
-      generatedClasses.clear()
-      generatedStaticForwarderClasses.clear()
-    }
-  }
-
-  /** Generates the Scala.js IR for a compilation unit
-   *  This method iterates over all the class and interface definitions
-   *  found in the compilation unit and emits their IR (.sjsir).
-   *
-   *  Some classes are never actually emitted:
-   *  - Classes representing primitive types
-   *  - The scala.Array class
-   *
-   *  TODO Some classes representing anonymous functions are not actually emitted.
-   *  Instead, a temporary representation of their `apply` method is built
-   *  and recorded, so that it can be inlined as a JavaScript anonymous
-   *  function in the method that instantiates it.
-   *
-   *  Other ClassDefs are emitted according to their nature:
-   *  * Non-native JS class       -> `genNonNativeJSClass()`
-   *  * Other JS type (<: js.Any) -> `genRawJSClassData()`
-   *  * Interface                 -> `genInterface()`
-   *  * Normal class              -> `genClass()`
-   */
-  private def genCompilationUnit(cunit: CompilationUnit): Unit = {
-    def collectTypeDefs(tree: Tree): List[TypeDef] = {
-      tree match {
-        case EmptyTree            => Nil
-        case PackageDef(_, stats) => stats.flatMap(collectTypeDefs)
-        case cd: TypeDef          => cd :: Nil
-        case _: ValDef            => Nil // module instance
-      }
-    }
-    val allTypeDefs = collectTypeDefs(cunit.tpdTree)
-
-    /* #13221 Set JavaStatic on all the Module fields of static module classes.
-     * This is necessary for `desugarIdent` not to crash in some obscure
-     * scenarios.
-     *
-     * !!! Part of this logic is duplicated in BCodeSkelBuilder.genPlainClass
-     *
-     * However, here we only do this for Module fields, not all fields.
-     */
-    for (typeDef <- allTypeDefs) {
-      if (typeDef.symbol.is(ModuleClass)) {
-        typeDef.symbol.info.decls.foreach { f =>
-          if (f.isField && f.is(Module))
-            f.setFlag(JavaStatic)
-        }
-      }
-    }
-
-    val (anonJSClassTypeDefs, otherTypeDefs) =
-      allTypeDefs.partition(td => td.symbol.isAnonymousClass && td.symbol.isJSType)
-
-    // Record the TypeDefs of anonymous JS classes to be lazily generated
-    for (td <- anonJSClassTypeDefs)
-      lazilyGeneratedAnonClasses(td.symbol) = td
-
-    /* Finally, we emit true code for the remaining class defs. */
-    for (td <- otherTypeDefs) {
-      val sym = td.symbol
-      implicit val pos: Position = sym.span
-
-      /* Do not actually emit code for primitive types nor scala.Array. */
-      val isPrimitive =
-        sym.isPrimitiveValueClass || sym == defn.ArrayClass
-
-      if (!isPrimitive) {
-        withScopedVars(
-            currentClassSym := sym
-        ) {
-          val tree = if (sym.isJSType) {
-            if (!sym.is(Trait) && sym.isNonNativeJSClass)
-              genNonNativeJSClass(td)
-            else
-              genRawJSClassData(td)
-          } else if (sym.is(Trait)) {
-            genInterface(td)
-          } else {
-            genScalaClass(td)
-          }
-
-          generatedClasses += tree
-        }
-      }
-    }
-
-    for (tree <- generatedClasses)
-      genIRFile(cunit, tree)
-
-    if (generatedStaticForwarderClasses.nonEmpty) {
-      /* #4148 Add generated static forwarder classes, except those that
-       * would collide with regular classes on case insensitive file systems.
-       */
-
-      /* I could not find any reference anywhere about what locale is used
-       * by case insensitive file systems to compare case-insensitively.
-       * In doubt, force the English locale, which is probably going to do
-       * the right thing in virtually all cases (especially if users stick
-       * to ASCII class names), and it has the merit of being deterministic,
-       * as opposed to using the OS' default locale.
-       * The JVM backend performs a similar test to emit a warning for
-       * conflicting top-level classes. However, it uses `toLowerCase()`
-       * without argument, which is not deterministic.
-       */
-      def caseInsensitiveNameOf(classDef: js.ClassDef): String =
-        classDef.name.name.nameString.toLowerCase(java.util.Locale.ENGLISH)
-
-      val generatedCaseInsensitiveNames =
-        generatedClasses.map(caseInsensitiveNameOf).toSet
-
-      for ((site, classDef) <- generatedStaticForwarderClasses) {
-        if (!generatedCaseInsensitiveNames.contains(caseInsensitiveNameOf(classDef))) {
-          genIRFile(cunit, classDef)
-        } else {
-          report.warning(
-              s"Not generating the static forwarders of ${classDef.name.name.nameString} " +
-              "because its name differs only in case from the name of another class or trait in this compilation unit.",
-              site.srcPos)
-        }
-      }
-    }
-  }
-
-  private def genIRFile(cunit: CompilationUnit, tree: ir.Trees.ClassDef): Unit = {
-    val outfile = getFileFor(cunit, tree.name.name, ".sjsir")
-    val output = outfile.bufferedOutput
-    try {
-      ir.Serializers.serialize(output, tree)
-    } finally {
-      output.close()
-    }
-  }
-
-  private def getFileFor(cunit: CompilationUnit, className: ClassName,
-      suffix: String): dotty.tools.io.AbstractFile = {
-    val outputDirectory = ctx.settings.outputDir.value
-    val pathParts = className.nameString.split('.')
-    val dir = pathParts.init.foldLeft(outputDirectory)(_.subdirectoryNamed(_))
-    val filename = pathParts.last
-    dir.fileNamed(filename + suffix)
-  }
-
-  // Generate a class --------------------------------------------------------
-
-  /** Gen the IR ClassDef for a Scala class definition (maybe a module class).
-   */
-  private def genScalaClass(td: TypeDef): js.ClassDef = {
-    val sym = td.symbol.asClass
-    implicit val pos: SourcePosition = sym.sourcePos
-
-    assert(!sym.is(Trait),
-        "genScalaClass() must be called only for normal classes: "+sym)
-    assert(sym.superClass != NoSymbol, sym)
-
-    if (hasDefaultCtorArgsAndJSModule(sym)) {
-      report.error(
-          "Implementation restriction: " +
-          "constructors of Scala classes cannot have default parameters if their companion module is JS native.",
-          td)
-    }
-
-    val classIdent = encodeClassNameIdent(sym)
-    val originalName = originalNameOfClass(sym)
-    val isHijacked = false //isHijackedBoxedClass(sym)
-
-    // Optimizer hints
-
-    val isDynamicImportThunk = sym.isSubClass(jsdefn.DynamicImportThunkClass)
-
-    def isStdLibClassWithAdHocInlineAnnot(sym: Symbol): Boolean = {
-      val fullName = sym.fullName.toString
-      (fullName.startsWith("scala.Tuple") && !fullName.endsWith("$")) ||
-      (fullName.startsWith("scala.collection.mutable.ArrayOps$of"))
-    }
-
-    val shouldMarkInline = (
-        isDynamicImportThunk ||
-        sym.hasAnnotation(jsdefn.InlineAnnot) ||
-        (sym.isAnonymousFunction && !sym.isSubClass(defn.PartialFunctionClass)) ||
-        isStdLibClassWithAdHocInlineAnnot(sym))
-
-    val optimizerHints = {
-      OptimizerHints.empty
-        .withInline(shouldMarkInline)
-        .withNoinline(sym.hasAnnotation(jsdefn.NoinlineAnnot))
-    }
-
-    // Generate members (constructor + methods)
-
-    val generatedNonFieldMembers = new mutable.ListBuffer[js.MemberDef]
-
-    val tpl = td.rhs.asInstanceOf[Template]
-    for (tree <- tpl.constr :: tpl.body) {
-      tree match {
-        case EmptyTree => ()
-
-        case vd: ValDef =>
-          // fields are added via genClassFields(), but we need to generate the JS native members
-          val sym = vd.symbol
-          if (!sym.is(Module) && sym.hasAnnotation(jsdefn.JSNativeAnnot))
-            generatedNonFieldMembers += genJSNativeMemberDef(vd)
-
-        case dd: DefDef =>
-          val sym = dd.symbol
-          if sym.hasAnnotation(jsdefn.JSNativeAnnot) then
-            if !sym.is(Accessor) then
-              generatedNonFieldMembers += genJSNativeMemberDef(dd)
-          else
-            generatedNonFieldMembers ++= genMethod(dd)
-
-        case _ =>
-          throw new FatalError("Illegal tree in body of genScalaClass(): " + tree)
-      }
-    }
-
-    // Generate fields and add to methods + ctors
-    val generatedMembers = genClassFields(td) ++ generatedNonFieldMembers.toList
-
-    // Generate member exports
-    val memberExports = jsExportsGen.genMemberExports(sym)
-
-    // Generate top-level export definitions
-    val topLevelExportDefs = jsExportsGen.genTopLevelExports(sym)
-
-    // Static initializer
-    val optStaticInitializer = {
-      // Initialization of reflection data, if required
-      val reflectInit = {
-        val enableReflectiveInstantiation = {
-          sym.baseClasses.exists { ancestor =>
-            ancestor.hasAnnotation(jsdefn.EnableReflectiveInstantiationAnnot)
-          }
-        }
-        if (enableReflectiveInstantiation)
-          genRegisterReflectiveInstantiation(sym).toList
-        else
-          Nil
-      }
-
-      // Initialization of the module because of field exports
-      val needsStaticModuleInit =
-        topLevelExportDefs.exists(_.isInstanceOf[js.TopLevelFieldExportDef])
-      val staticModuleInit =
-        if (!needsStaticModuleInit) Nil
-        else List(genLoadModule(sym))
-
-      val staticInitializerStats = reflectInit ::: staticModuleInit
-      if (staticInitializerStats.nonEmpty)
-        List(genStaticConstructorWithStats(ir.Names.StaticInitializerName, js.Block(staticInitializerStats)))
-      else
-        Nil
-    }
-
-    val optDynamicImportForwarder =
-      if (isDynamicImportThunk) List(genDynamicImportForwarder(sym))
-      else Nil
-
-    val allMemberDefsExceptStaticForwarders =
-      generatedMembers ::: memberExports ::: optStaticInitializer ::: optDynamicImportForwarder
-
-    // Add static forwarders
-    val allMemberDefs = if (!isCandidateForForwarders(sym)) {
-      allMemberDefsExceptStaticForwarders
-    } else {
-      if (isStaticModule(sym)) {
-        /* If the module class has no linked class, we must create one to
-         * hold the static forwarders. Otherwise, this is going to be handled
-         * when generating the companion class.
-         */
-        if (!sym.linkedClass.exists) {
-          val forwarders = genStaticForwardersFromModuleClass(Nil, sym)
-          if (forwarders.nonEmpty) {
-            val forwardersClassDef = js.ClassDef(
-                js.ClassIdent(ClassName(classIdent.name.nameString.stripSuffix("$"))),
-                originalName,
-                ClassKind.Class,
-                None,
-                Some(js.ClassIdent(ir.Names.ObjectClass)),
-                Nil,
-                None,
-                None,
-                forwarders,
-                Nil
-            )(js.OptimizerHints.empty)
-            generatedStaticForwarderClasses += sym -> forwardersClassDef
-          }
-        }
-        allMemberDefsExceptStaticForwarders
-      } else {
-        val forwarders = genStaticForwardersForClassOrInterface(
-            allMemberDefsExceptStaticForwarders, sym)
-        allMemberDefsExceptStaticForwarders ::: forwarders
-      }
-    }
-
-    // Hashed definitions of the class
-    val hashedDefs = ir.Hashers.hashMemberDefs(allMemberDefs)
-
-    // The complete class definition
-    val kind =
-      if (isStaticModule(sym)) ClassKind.ModuleClass
-      else if (isHijacked) ClassKind.HijackedClass
-      else ClassKind.Class
-
-    val classDefinition = js.ClassDef(
-        classIdent,
-        originalName,
-        kind,
-        None,
-        Some(encodeClassNameIdent(sym.superClass)),
-        genClassInterfaces(sym, forJSClass = false),
-        None,
-        None,
-        hashedDefs,
-        topLevelExportDefs)(
-        optimizerHints)
-
-    classDefinition
-  }
-
-  /** Gen the IR ClassDef for a Scala.js-defined JS class. */
-  private def genNonNativeJSClass(td: TypeDef): js.ClassDef = {
-    val sym = td.symbol.asClass
-    implicit val pos: SourcePosition = sym.sourcePos
-
-    assert(sym.isNonNativeJSClass,
-        i"genNonNativeJSClass() must be called only for non-native JS classes: $sym")
-    assert(sym.superClass != NoSymbol, sym)
-
-    if (hasDefaultCtorArgsAndJSModule(sym)) {
-      report.error(
-          "Implementation restriction: " +
-          "constructors of non-native JS classes cannot have default parameters if their companion module is JS native.",
-          td)
-    }
-
-    val classIdent = encodeClassNameIdent(sym)
-    val originalName = originalNameOfClass(sym)
-
-    // Generate members (constructor + methods)
-
-    val constructorTrees = new mutable.ListBuffer[DefDef]
-    val generatedMethods = new mutable.ListBuffer[js.MethodDef]
-    val dispatchMethodNames = new mutable.ListBuffer[JSName]
-
-    val tpl = td.rhs.asInstanceOf[Template]
-    for (tree <- tpl.constr :: tpl.body) {
-      tree match {
-        case EmptyTree => ()
-
-        case _: ValDef =>
-          () // fields are added via genClassFields()
-
-        case dd: DefDef =>
-          val sym = dd.symbol
-          val exposed = sym.isJSExposed
-
-          if (sym.isClassConstructor) {
-            constructorTrees += dd
-          } else if (exposed && sym.is(Accessor, butNot = Lazy)) {
-            // Exposed accessors must not be emitted, since the field they access is enough.
-          } else if (sym.hasAnnotation(jsdefn.JSOptionalAnnot)) {
-            // Optional methods must not be emitted
-          } else {
-            generatedMethods ++= genMethod(dd)
-
-            // Collect the names of the dispatchers we have to create
-            if (exposed && !sym.is(Deferred)) {
-              /* We add symbols that we have to expose here. This way we also
-               * get inherited stuff that is implemented in this class.
-               */
-              dispatchMethodNames += sym.jsName
-            }
-          }
-
-        case _ =>
-          throw new FatalError("Illegal tree in gen of genNonNativeJSClass(): " + tree)
-      }
-    }
-
-    // Static members (exported from the companion object)
-    val staticMembers = {
-      val module = sym.companionModule
-      if (!module.exists) {
-        Nil
-      } else {
-        val companionModuleClass = module.moduleClass
-        val exports = withScopedVars(currentClassSym := companionModuleClass) {
-          jsExportsGen.genStaticExports(companionModuleClass)
-        }
-        if (exports.exists(_.isInstanceOf[js.JSFieldDef])) {
-          val classInitializer =
-            genStaticConstructorWithStats(ir.Names.ClassInitializerName, genLoadModule(companionModuleClass))
-          exports :+ classInitializer
-        } else {
-          exports
-        }
-      }
-    }
-
-    val topLevelExports = jsExportsGen.genTopLevelExports(sym)
-
-    val (generatedConstructor, jsClassCaptures) = withNewLocalNameScope {
-      val isNested = sym.isNestedJSClass
-
-      if (isNested)
-        localNames.reserveLocalName(JSSuperClassParamName)
-
-      val (captures, ctor) = genJSClassCapturesAndConstructor(constructorTrees.toList)
-
-      val jsClassCaptures = if (isNested) {
-        val superParam = js.ParamDef(js.LocalIdent(JSSuperClassParamName),
-            NoOriginalName, jstpe.AnyType, mutable = false)
-        Some(superParam :: captures)
-      } else {
-        assert(captures.isEmpty, s"found non nested JS class with captures $captures at $pos")
-        None
-      }
-
-      (ctor, jsClassCaptures)
-    }
-
-    // Generate fields (and add to methods + ctors)
-    val generatedMembers = {
-      genClassFields(td) :::
-      generatedConstructor ::
-      jsExportsGen.genJSClassDispatchers(sym, dispatchMethodNames.result().distinct) :::
-      generatedMethods.toList :::
-      staticMembers
-    }
-
-    // Hashed definitions of the class
-    val hashedMemberDefs = ir.Hashers.hashMemberDefs(generatedMembers)
-
-    // The complete class definition
-    val kind =
-      if (isStaticModule(sym)) ClassKind.JSModuleClass
-      else ClassKind.JSClass
-
-    val classDefinition = js.ClassDef(
-        classIdent,
-        originalNameOfClass(sym),
-        kind,
-        jsClassCaptures,
-        Some(encodeClassNameIdent(sym.superClass)),
-        genClassInterfaces(sym, forJSClass = true),
-        jsSuperClass = jsClassCaptures.map(_.head.ref),
-        None,
-        hashedMemberDefs,
-        topLevelExports)(
-        OptimizerHints.empty)
-
-    classDefinition
-  }
-
-  /** Gen the IR ClassDef for a raw JS class or trait.
-   */
-  private def genRawJSClassData(td: TypeDef): js.ClassDef = {
-    val sym = td.symbol.asClass
-    implicit val pos: Position = sym.span
-
-    val classIdent = encodeClassNameIdent(sym)
-    val kind = {
-      if (sym.is(Trait)) ClassKind.AbstractJSType
-      else if (sym.is(ModuleClass)) ClassKind.NativeJSModuleClass
-      else ClassKind.NativeJSClass
-    }
-    val superClass =
-      if (sym.is(Trait)) None
-      else Some(encodeClassNameIdent(sym.superClass))
-    val jsNativeLoadSpec = computeJSNativeLoadSpecOfClass(sym)
-
-    js.ClassDef(
-        classIdent,
-        originalNameOfClass(sym),
-        kind,
-        None,
-        superClass,
-        genClassInterfaces(sym, forJSClass = false),
-        None,
-        jsNativeLoadSpec,
-        Nil,
-        Nil)(
-        OptimizerHints.empty)
-  }
-
-  /** Gen the IR ClassDef for an interface definition.
-   */
-  private def genInterface(td: TypeDef): js.ClassDef = {
-    val sym = td.symbol.asClass
-    implicit val pos: SourcePosition = sym.sourcePos
-
-    val classIdent = encodeClassNameIdent(sym)
-
-    val generatedMethods = new mutable.ListBuffer[js.MethodDef]
-
-    val tpl = td.rhs.asInstanceOf[Template]
-    for (tree <- tpl.constr :: tpl.body) {
-      tree match {
-        case EmptyTree  => ()
-        case dd: DefDef => generatedMethods ++= genMethod(dd)
-        case _ =>
-          throw new FatalError(
-            i"""Illegal tree in gen of genInterface(): $tree
-               |class = $td
-               |in ${ctx.compilationUnit}""")
-      }
-    }
-
-    val superInterfaces = genClassInterfaces(sym, forJSClass = false)
-
-    val genMethodsList = generatedMethods.toList
-    val allMemberDefs =
-      if (!isCandidateForForwarders(sym)) genMethodsList
-      else genMethodsList ::: genStaticForwardersForClassOrInterface(genMethodsList, sym)
-
-    // Hashed definitions of the interface
-    val hashedDefs = ir.Hashers.hashMemberDefs(allMemberDefs)
-
-    js.ClassDef(
-        classIdent,
-        originalNameOfClass(sym),
-        ClassKind.Interface,
-        None,
-        None,
-        superInterfaces,
-        None,
-        None,
-        hashedDefs,
-        Nil)(
-        OptimizerHints.empty)
-  }
-
-  private def genClassInterfaces(sym: ClassSymbol, forJSClass: Boolean)(
-      implicit pos: Position): List[js.ClassIdent] = {
-    for {
-      intf <- sym.directlyInheritedTraits
-      if !(forJSClass && intf == defn.DynamicClass)
-    } yield {
-      encodeClassNameIdent(intf)
-    }
-  }
-
-  // Static forwarders -------------------------------------------------------
-
-  /* This mimics the logic in BCodeHelpers.addForwarders and the code that
-   * calls it, except that we never have collisions with existing methods in
-   * the companion class. This is because in the IR, only methods with the
-   * same `MethodName` (including signature) and that are also
-   * `PublicStatic` would collide. There should never be an actual collision
-   * because the only `PublicStatic` methods that are otherwise generated are
-   * the bodies of SAMs, which have mangled names. If that assumption is
-   * broken, an error message is emitted asking the user to report a bug.
-   *
-   * It is important that we always emit forwarders, because some Java APIs
-   * actually have a public static method and a public instance method with
-   * the same name. For example the class `Integer` has a
-   * `def hashCode(): Int` and a `static def hashCode(Int): Int`. The JVM
-   * back-end considers them as colliding because they have the same name,
-   * but we must not.
-   *
-   * By default, we only emit forwarders for top-level objects, like the JVM
-   * back-end. However, if requested via a compiler option, we enable them
-   * for all static objects. This is important so we can implement static
-   * methods of nested static classes of JDK APIs (see scala-js/#3950).
-   */
-
-  /** Is the given Scala class, interface or module class a candidate for
-   *  static forwarders?
-   *
-   *  - the flag `-XnoForwarders` is not set to true, and
-   *  - the symbol is static, and
-   *  - either of both of the following is true:
-   *    - the flag `-scalajsGenStaticForwardersForNonTopLevelObjects` is set to true, or
-   *    - the symbol was originally at the package level
-   *
-   *  Other than the Scala.js-specific flag, and the fact that we also consider
-   *  interfaces, this performs the same tests as the JVM back-end.
-   */
-  def isCandidateForForwarders(sym: Symbol): Boolean = {
-    !ctx.settings.XnoForwarders.value && sym.isStatic && {
-      ctx.settings.scalajsGenStaticForwardersForNonTopLevelObjects.value || {
-        atPhase(flattenPhase) {
-          toDenot(sym).owner.is(PackageClass)
-        }
-      }
-    }
-  }
-
-  /** Gen the static forwarders to the members of a class or interface for
-   *  methods of its companion object.
-   *
-   *  This is only done if there exists a companion object and it is not a JS
-   *  type.
-   *
-   *  Precondition: `isCandidateForForwarders(sym)` is true
-   */
-  def genStaticForwardersForClassOrInterface(
-      existingMembers: List[js.MemberDef], sym: Symbol)(
-      implicit pos: SourcePosition): List[js.MemberDef] = {
-    val module = sym.companionModule
-    if (!module.exists) {
-      Nil
-    } else {
-      val moduleClass = module.moduleClass
-      if (!moduleClass.isJSType)
-        genStaticForwardersFromModuleClass(existingMembers, moduleClass)
-      else
-        Nil
-    }
-  }
-
-  /** Gen the static forwarders for the methods of a module class.
-   *
-   *  Precondition: `isCandidateForForwarders(moduleClass)` is true
-   */
-  def genStaticForwardersFromModuleClass(existingMembers: List[js.MemberDef],
-      moduleClass: Symbol)(
-      implicit pos: SourcePosition): List[js.MemberDef] = {
-
-    assert(moduleClass.is(ModuleClass), moduleClass)
-
-    val existingPublicStaticMethodNames = existingMembers.collect {
-      case js.MethodDef(flags, name, _, _, _, _)
-          if flags.namespace == js.MemberNamespace.PublicStatic =>
-        name.name
-    }.toSet
-
-    val members = {
-      moduleClass.info.membersBasedOnFlags(required = Flags.Method,
-          excluded = Flags.ExcludedForwarder).map(_.symbol)
-    }
-
-    def isExcluded(m: Symbol): Boolean = {
-      def hasAccessBoundary = m.accessBoundary(defn.RootClass) ne defn.RootClass
-
-      def isOfJLObject: Boolean = m.owner eq defn.ObjectClass
-
-      def isDefaultParamOfJSNativeDef: Boolean = {
-        m.name.is(DefaultGetterName) && {
-          val info = new DefaultParamInfo(m)
-          !info.isForConstructor && info.attachedMethod.hasAnnotation(jsdefn.JSNativeAnnot)
-        }
-      }
-
-      m.is(Deferred)
-        || m.isConstructor
-        || hasAccessBoundary
-        || isOfJLObject
-        || m.hasAnnotation(jsdefn.JSNativeAnnot) || isDefaultParamOfJSNativeDef // #4557
-    }
-
-    val forwarders = for {
-      m <- members
-      if !isExcluded(m)
-    } yield {
-      withNewLocalNameScope {
-        val flags = js.MemberFlags.empty.withNamespace(js.MemberNamespace.PublicStatic)
-        val methodIdent = encodeMethodSym(m)
-        val originalName = originalNameOfMethod(m)
-        val jsParams = for {
-          (paramName, paramInfo) <- m.info.paramNamess.flatten.zip(m.info.paramInfoss.flatten)
-        } yield {
-          js.ParamDef(freshLocalIdent(paramName), NoOriginalName,
-              toIRType(paramInfo), mutable = false)
-        }
-        val resultType = toIRType(m.info.resultType)
-
-        if (existingPublicStaticMethodNames.contains(methodIdent.name)) {
-          report.error(
-              "Unexpected situation: found existing public static method " +
-              s"${methodIdent.name.nameString} in the companion class of " +
-              s"${moduleClass.fullName}; cannot generate a static forwarder " +
-              "the method of the same name in the object." +
-              "Please report this as a bug in the Scala.js support in dotty.",
-              pos)
-        }
-
-        js.MethodDef(flags, methodIdent, originalName, jsParams, resultType, Some {
-          genApplyMethod(genLoadModule(moduleClass), m, jsParams.map(_.ref))
-        })(OptimizerHints.empty, None)
-      }
-    }
-
-    forwarders.toList
-  }
-
-  // Generate the fields of a class ------------------------------------------
-
-  /** Gen definitions for the fields of a class. */
-  private def genClassFields(td: TypeDef): List[js.MemberDef] = {
-    val classSym = td.symbol.asClass
-    assert(currentClassSym.get == classSym,
-        "genClassFields called with a ClassDef other than the current one")
-
-    val isJSClass = classSym.isNonNativeJSClass
-
-    // Term members that are neither methods nor modules are fields
-    classSym.info.decls.filter { f =>
-      !f.isOneOf(MethodOrModule) && f.isTerm
-        && !f.hasAnnotation(jsdefn.JSNativeAnnot)
-        && !f.hasAnnotation(jsdefn.JSOptionalAnnot)
-        && !f.hasAnnotation(jsdefn.JSExportStaticAnnot)
-    }.flatMap({ f =>
-      implicit val pos = f.span
-
-      val isTopLevelExport = f.hasAnnotation(jsdefn.JSExportTopLevelAnnot)
-      val isJavaStatic = f.is(JavaStatic)
-      assert(!(isTopLevelExport && isJavaStatic),
-          em"found ${f.fullName} which is both a top-level export and a Java static")
-      val isStaticField = isTopLevelExport || isJavaStatic
-
-      val namespace = if isStaticField then js.MemberNamespace.PublicStatic else js.MemberNamespace.Public
-      val mutable = isStaticField || f.is(Mutable)
-
-      val flags = js.MemberFlags.empty.withMutable(mutable).withNamespace(namespace)
-
-      val irTpe0 =
-        if (isJSClass) genExposedFieldIRType(f)
-        else if (isTopLevelExport) jstpe.AnyType
-        else toIRType(f.info)
-
-      // scala-js/#4370 Fields cannot have type NothingType
-      val irTpe =
-        if (irTpe0 == jstpe.NothingType) encodeClassType(defn.NothingClass)
-        else irTpe0
-
-      if (isJSClass && f.isJSExposed)
-        js.JSFieldDef(flags, genExpr(f.jsName)(f.sourcePos), irTpe) :: Nil
-      else
-        val fieldIdent = encodeFieldSym(f)
-        val originalName = originalNameOfField(f)
-        val fieldDef = js.FieldDef(flags, fieldIdent, originalName, irTpe)
-        val optionalStaticFieldGetter =
-          if isJavaStatic then
-            // Here we are generating a public static getter for the static field,
-            // this is its API for other units. This is necessary for singleton
-            // enum values, which are backed by static fields.
-            val className = encodeClassName(classSym)
-            val body = js.Block(
-                js.LoadModule(className),
-                js.SelectStatic(className, fieldIdent)(irTpe))
-            js.MethodDef(js.MemberFlags.empty.withNamespace(js.MemberNamespace.PublicStatic),
-                encodeStaticMemberSym(f), originalName, Nil, irTpe,
-                Some(body))(
-                OptimizerHints.empty, None) :: Nil
-          else
-            Nil
-        fieldDef :: optionalStaticFieldGetter
-    }).toList
-  }
-
-  def genExposedFieldIRType(f: Symbol): jstpe.Type = {
-    val tpeEnteringPosterasure = atPhase(elimErasedValueTypePhase)(f.info)
-    tpeEnteringPosterasure match {
-      case tpe: ErasedValueType =>
-        /* Here, we must store the field as the boxed representation of
-         * the value class. The default value of that field, as
-         * initialized at the time the instance is created, will
-         * therefore be null. This will not match the behavior we would
-         * get in a Scala class. To match the behavior, we would need to
-         * initialized to an instance of the boxed representation, with
-         * an underlying value set to the zero of its type. However we
-         * cannot implement that, so we live with the discrepancy.
-         *
-         * In dotc this is usually not an issue, because it unboxes `null` to
-         * the zero of the underlying type, unlike scalac which throws an NPE.
-         */
-        jstpe.ClassType(encodeClassName(tpe.tycon.typeSymbol))
-
-      case _ =>
-        // Other types are not boxed, so we can initialized them to their true zero.
-        toIRType(f.info)
-    }
-  }
-
-  // Static initializers -----------------------------------------------------
-
-  private def genStaticConstructorWithStats(name: MethodName, stats: js.Tree)(
-      implicit pos: Position): js.MethodDef = {
-    js.MethodDef(
-        js.MemberFlags.empty.withNamespace(js.MemberNamespace.StaticConstructor),
-        js.MethodIdent(name),
-        NoOriginalName,
-        Nil,
-        jstpe.NoType,
-        Some(stats))(
-        OptimizerHints.empty, None)
-  }
-
-  private def genRegisterReflectiveInstantiation(sym: Symbol)(
-      implicit pos: SourcePosition): Option[js.Tree] = {
-    if (isStaticModule(sym))
-      genRegisterReflectiveInstantiationForModuleClass(sym)
-    else if (sym.is(ModuleClass))
-      None // scala-js#3228
-    else if (sym.is(Lifted) && !sym.originalOwner.isClass)
-      None // scala-js#3227
-    else
-      genRegisterReflectiveInstantiationForNormalClass(sym)
-  }
-
-  private def genRegisterReflectiveInstantiationForModuleClass(sym: Symbol)(
-      implicit pos: SourcePosition): Option[js.Tree] = {
-    val fqcnArg = js.StringLiteral(sym.fullName.toString)
-    val runtimeClassArg = js.ClassOf(toTypeRef(sym.info))
-    val loadModuleFunArg =
-      js.Closure(arrow = true, Nil, Nil, None, genLoadModule(sym), Nil)
-
-    val stat = genApplyMethod(
-        genLoadModule(jsdefn.ReflectModule),
-        jsdefn.Reflect_registerLoadableModuleClass,
-        List(fqcnArg, runtimeClassArg, loadModuleFunArg))
-
-    Some(stat)
-  }
-
-  private def genRegisterReflectiveInstantiationForNormalClass(sym: Symbol)(
-      implicit pos: SourcePosition): Option[js.Tree] = {
-    val ctors =
-      if (sym.is(Abstract)) Nil
-      else sym.info.member(nme.CONSTRUCTOR).alternatives.map(_.symbol).filter(m => !m.isOneOf(Private | Protected))
-
-    if (ctors.isEmpty) {
-      None
-    } else {
-      val constructorsInfos = for {
-        ctor <- ctors
-      } yield {
-        withNewLocalNameScope {
-          val (parameterTypes, formalParams, actualParams) = (for {
-            (paramName, paramInfo) <- ctor.info.paramNamess.flatten.zip(ctor.info.paramInfoss.flatten)
-          } yield {
-            val paramType = js.ClassOf(toTypeRef(paramInfo))
-            val paramDef = js.ParamDef(freshLocalIdent(paramName),
-                NoOriginalName, jstpe.AnyType, mutable = false)
-            val actualParam = unbox(paramDef.ref, paramInfo)
-            (paramType, paramDef, actualParam)
-          }).unzip3
-
-          val paramTypesArray = js.JSArrayConstr(parameterTypes)
-
-          val newInstanceFun = js.Closure(arrow = true, Nil, formalParams, None, {
-            js.New(encodeClassName(sym), encodeMethodSym(ctor), actualParams)
-          }, Nil)
-
-          js.JSArrayConstr(List(paramTypesArray, newInstanceFun))
-        }
-      }
-
-      val fqcnArg = js.StringLiteral(sym.fullName.toString)
-      val runtimeClassArg = js.ClassOf(toTypeRef(sym.info))
-      val ctorsInfosArg = js.JSArrayConstr(constructorsInfos)
-
-      val stat = genApplyMethod(
-          genLoadModule(jsdefn.ReflectModule),
-          jsdefn.Reflect_registerInstantiatableClass,
-          List(fqcnArg, runtimeClassArg, ctorsInfosArg))
-
-      Some(stat)
-    }
-  }
-
-  // Constructor of a non-native JS class ------------------------------------
-
-  def genJSClassCapturesAndConstructor(constructorTrees: List[DefDef])(
-      implicit pos: SourcePosition): (List[js.ParamDef], js.JSConstructorDef) = {
-    /* We need to merge all Scala constructors into a single one because the
-     * IR, like JavaScript, only allows a single one.
-     *
-     * We do this by applying:
-     * 1. Applying runtime type based dispatch, just like exports.
-     * 2. Splitting secondary ctors into parts before and after the `this` call.
-     * 3. Topo-sorting all constructor statements and including/excluding
-     *    them based on the overload that was chosen.
-     */
-
-    val (primaryTree :: Nil, secondaryTrees) =
-      constructorTrees.partition(_.symbol.isPrimaryConstructor): @unchecked
-
-    val primaryCtor = genPrimaryJSClassCtor(primaryTree)
-    val secondaryCtors = secondaryTrees.map(genSecondaryJSClassCtor(_))
-
-    // VarDefs for the parameters of all constructors.
-    val paramVarDefs = for {
-      vparam <- constructorTrees.flatMap(_.paramss.flatten)
-    } yield {
-      val sym = vparam.symbol
-      val tpe = toIRType(sym.info)
-      js.VarDef(encodeLocalSym(sym), originalNameOfLocal(sym), tpe, mutable = true, jstpe.zeroOf(tpe))(vparam.span)
-    }
-
-    /* organize constructors in a called-by tree
-     * (the implicit root is the primary constructor)
-     */
-    val ctorTree = {
-      val ctorToChildren = secondaryCtors
-        .groupBy(_.targetCtor)
-        .withDefaultValue(Nil)
-
-      /* when constructing the call-by tree, we use pre-order traversal to
-       * assign overload numbers.
-       * this puts all descendants of a ctor in a range of overloads numbers.
-       *
-       * this property is useful, later, when we need to make statements
-       * conditional based on the chosen overload.
-       */
-      var nextOverloadNum = 0
-      def subTree[T <: JSCtor](ctor: T): ConstructorTree[T] = {
-        val overloadNum = nextOverloadNum
-        nextOverloadNum += 1
-        val subtrees = ctorToChildren(ctor.sym).map(subTree(_))
-        new ConstructorTree(overloadNum, ctor, subtrees)
-      }
-
-      subTree(primaryCtor)
-    }
-
-    /* prepare overload dispatch for all constructors.
-     * as a side-product, we retrieve the capture parameters.
-     */
-    val (exports, jsClassCaptures) = {
-      val exports = List.newBuilder[jsExportsGen.Exported]
-      val jsClassCaptures = List.newBuilder[js.ParamDef]
-
-      def add(tree: ConstructorTree[_ <: JSCtor]): Unit = {
-        val (e, c) = genJSClassCtorDispatch(tree.ctor.sym,
-            tree.ctor.paramsAndInfo, tree.overloadNum)
-        exports += e
-        jsClassCaptures ++= c
-        tree.subCtors.foreach(add(_))
-      }
-
-      add(ctorTree)
-
-      (exports.result(), jsClassCaptures.result())
-    }
-
-    // The name 'constructor' is used for error reporting here
-    val (formalArgs, restParam, overloadDispatchBody) =
-      jsExportsGen.genOverloadDispatch(JSName.Literal("constructor"), exports, jstpe.IntType)
-
-    val overloadVar = js.VarDef(freshLocalIdent("overload"), NoOriginalName,
-        jstpe.IntType, mutable = false, overloadDispatchBody)
-
-    val constructorBody = wrapJSCtorBody(
-      paramVarDefs :+ overloadVar,
-      genJSClassCtorBody(overloadVar.ref, ctorTree),
-      js.Undefined() :: Nil
-    )
-
-    val constructorDef = js.JSConstructorDef(
-        js.MemberFlags.empty.withNamespace(js.MemberNamespace.Constructor),
-        formalArgs, restParam, constructorBody)(OptimizerHints.empty, None)
-
-    (jsClassCaptures, constructorDef)
-  }
-
-  private def genPrimaryJSClassCtor(dd: DefDef): PrimaryJSCtor = {
-    val sym = dd.symbol
-    val Block(stats, _) = dd.rhs: @unchecked
-    assert(sym.isPrimaryConstructor, s"called with non-primary ctor: $sym")
-
-    var jsSuperCall: Option[js.JSSuperConstructorCall] = None
-    val jsStats = List.newBuilder[js.Tree]
-
-    /* Move all statements after the super constructor call since JS
-     * cannot access `this` before the super constructor call.
-     *
-     * dotc inserts statements before the super constructor call for param
-     * accessor initializers (including val's and var's declared in the
-     * params). We move those after the super constructor call, and are
-     * therefore executed later than for a Scala class.
-     */
-    withPerMethodBodyState(sym) {
-      stats.foreach {
-        case tree @ Apply(fun @ Select(Super(This(_), _), _), args)
-            if fun.symbol.isClassConstructor =>
-          assert(jsSuperCall.isEmpty, s"Found 2 JS Super calls at ${dd.sourcePos}")
-          implicit val pos: Position = tree.span
-          jsSuperCall = Some(js.JSSuperConstructorCall(genActualJSArgs(fun.symbol, args)))
-
-        case stat =>
-          val jsStat = genStat(stat)
-          assert(jsSuperCall.isDefined || !jsStat.isInstanceOf[js.VarDef],
-              "Trying to move a local VarDef after the super constructor call of a non-native JS class at " +
-              dd.sourcePos)
-          jsStats += jsStat
-      }
-    }
-
-    assert(jsSuperCall.isDefined,
-        s"Did not find Super call in primary JS construtor at ${dd.sourcePos}")
-
-    new PrimaryJSCtor(sym, genParamsAndInfo(sym, dd.paramss),
-        js.JSConstructorBody(Nil, jsSuperCall.get, jsStats.result())(dd.span))
-  }
-
-  private def genSecondaryJSClassCtor(dd: DefDef): SplitSecondaryJSCtor = {
-    val sym = dd.symbol
-    assert(!sym.isPrimaryConstructor, s"called with primary ctor $sym")
-
-    def flattenBlocks(t: Tree): List[Tree] = t match {
-      case Block(stats, expr) => (stats :+ expr).flatMap(flattenBlocks)
-      case _                  => t :: Nil
-    }
-    val stats = flattenBlocks(dd.rhs)
-
-    val beforeThisCall = List.newBuilder[js.Tree]
-    var thisCall: Option[(Symbol, List[js.Tree])] = None
-    val afterThisCall = List.newBuilder[js.Tree]
-
-    withPerMethodBodyState(sym) {
-      stats.foreach {
-        case tree @ Apply(fun @ Select(This(_), _), args)
-            if fun.symbol.isClassConstructor =>
-          assert(thisCall.isEmpty,
-              s"duplicate this() call in secondary JS constructor at ${dd.sourcePos}")
-
-          implicit val pos: Position = tree.span
-          val sym = fun.symbol
-          thisCall = Some((sym, genActualArgs(sym, args)))
-
-        case stat =>
-          val jsStat = genStat(stat)
-          if (thisCall.isEmpty)
-            beforeThisCall += jsStat
-          else
-            afterThisCall += jsStat
-      }
-    }
-
-    assert(thisCall.isDefined,
-        i"could not find the this() call in secondary JS constructor at ${dd.sourcePos}:\n${stats.map(_.show).mkString("\n")}")
-    val Some((targetCtor, ctorArgs)) = thisCall: @unchecked
-
-    new SplitSecondaryJSCtor(sym, genParamsAndInfo(sym, dd.paramss),
-        beforeThisCall.result(), targetCtor, ctorArgs, afterThisCall.result())
-  }
-
-  private def genParamsAndInfo(ctorSym: Symbol,
-      vparamss: List[ParamClause]): List[(Symbol, JSParamInfo)] = {
-    implicit val pos: SourcePosition = ctorSym.sourcePos
-
-    val paramSyms = if (vparamss.isEmpty) Nil else vparamss.head.map(_.symbol)
-    paramSyms.zip(ctorSym.jsParamInfos)
-  }
-
-  private def genJSClassCtorDispatch(ctorSym: Symbol,
-      allParamsAndInfos: List[(Symbol, JSParamInfo)],
-      overloadNum: Int): (jsExportsGen.Exported, List[js.ParamDef]) = {
-
-    implicit val pos: SourcePosition = ctorSym.sourcePos
-
-    /* `allParams` are the parameters as seen from inside the constructor body,
-     * i.e., the ones generated by the trees in the constructor body.
-     */
-    val (captureParamsAndInfos, normalParamsAndInfos) =
-      allParamsAndInfos.partition(_._2.capture)
-
-    /* For class captures, we need to generate different names than the ones
-     * used by the constructor body. This is necessary so that we can forward
-     * captures properly between constructor delegation calls.
-     */
-    val (jsClassCaptures, captureAssigns) = (for {
-      (param, info) <- captureParamsAndInfos
-    } yield {
-      val ident = freshLocalIdent(param.name.toTermName)
-      val jsClassCapture =
-        js.ParamDef(ident, originalNameOfLocal(param), toIRType(info.info), mutable = false)
-      val captureAssign =
-        js.Assign(genVarRef(param), jsClassCapture.ref)
-      (jsClassCapture, captureAssign)
-    }).unzip
-
-    val normalInfos = normalParamsAndInfos.map(_._2).toIndexedSeq
-
-    val jsExport = new jsExportsGen.Exported(ctorSym, normalInfos) {
-      def genBody(formalArgsRegistry: jsExportsGen.FormalArgsRegistry): js.Tree = {
-        val paramAssigns = for {
-          ((param, info), i) <- normalParamsAndInfos.zipWithIndex
-        } yield {
-          val rhs = jsExportsGen.genScalaArg(this, i, formalArgsRegistry, info, static = true,
-              captures = captureParamsAndInfos.map(pi => genVarRef(pi._1)))(
-              prevArgsCount => normalParamsAndInfos.take(prevArgsCount).map(pi => genVarRef(pi._1)))
-
-          js.Assign(genVarRef(param), rhs)
-        }
-
-        js.Block(captureAssigns ::: paramAssigns, js.IntLiteral(overloadNum))
-      }
-    }
-
-    (jsExport, jsClassCaptures)
-  }
-
-  /** Generates a JS constructor body based on a constructor tree. */
-  private def genJSClassCtorBody(overloadVar: js.VarRef,
-      ctorTree: ConstructorTree[PrimaryJSCtor])(implicit pos: Position): js.JSConstructorBody = {
-
-    /* generates a statement that conditionally executes body iff the chosen
-     * overload is any of the descendants of `tree` (including itself).
-     *
-     * here we use the property from building the trees, that a set of
-     * descendants always has a range of overload numbers.
-     */
-    def ifOverload(tree: ConstructorTree[_], body: js.Tree): js.Tree = body match {
-      case js.Skip() => js.Skip()
-
-      case body =>
-        val x = overloadVar
-        val cond = {
-          import tree.{lo, hi}
-
-          if (lo == hi) {
-            js.BinaryOp(js.BinaryOp.Int_==, js.IntLiteral(lo), x)
-          } else {
-            val lhs = js.BinaryOp(js.BinaryOp.Int_<=, js.IntLiteral(lo), x)
-            val rhs = js.BinaryOp(js.BinaryOp.Int_<=, x, js.IntLiteral(hi))
-            js.If(lhs, rhs, js.BooleanLiteral(false))(jstpe.BooleanType)
-          }
-        }
-
-        js.If(cond, body, js.Skip())(jstpe.NoType)
-    }
-
-    /* preStats / postStats use pre/post order traversal respectively to
-     * generate a topo-sorted sequence of statements.
-     */
-
-    def preStats(tree: ConstructorTree[SplitSecondaryJSCtor],
-        nextParamsAndInfo: List[(Symbol, JSParamInfo)]): js.Tree = {
-      val inner = tree.subCtors.map(preStats(_, tree.ctor.paramsAndInfo))
-
-      assert(tree.ctor.ctorArgs.size == nextParamsAndInfo.size, "param count mismatch")
-      val paramsInfosAndArgs = nextParamsAndInfo.zip(tree.ctor.ctorArgs)
-
-      val (captureParamsInfosAndArgs, normalParamsInfosAndArgs) =
-        paramsInfosAndArgs.partition(_._1._2.capture)
-
-      val captureAssigns = for {
-        ((param, _), arg) <- captureParamsInfosAndArgs
-      } yield {
-        js.Assign(genVarRef(param), arg)
-      }
-
-      val normalAssigns = for {
-        (((param, info), arg), i) <- normalParamsInfosAndArgs.zipWithIndex
-      } yield {
-        val newArg = arg match {
-          case js.Transient(UndefinedParam) =>
-            /* Go full circle: We have ignored the default param getter for
-             * this, we'll create it again.
-             *
-             * This seems not optimal: We could simply not ignore the calls to
-             * default param getters in the first place.
-             *
-             * However, this proves to be difficult: Because of translations in
-             * earlier phases, calls to default param getters may be assigned
-             * to temporary variables first (see the undefinedDefaultParams
-             * ScopedVar). If this happens, it becomes increasingly difficult
-             * to distinguish a default param getter call for a constructor
-             * call of *this* instance (in which case we would want to keep
-             * the default param getter call) from one for a *different*
-             * instance (in which case we would want to discard the default
-             * param getter call)
-             *
-             * Because of this, it ends up being easier to just re-create the
-             * default param getter call if necessary.
-             */
-            implicit val pos: SourcePosition = tree.ctor.sym.sourcePos
-            jsExportsGen.genCallDefaultGetter(tree.ctor.sym, i, static = false,
-                captures = captureParamsInfosAndArgs.map(p => genVarRef(p._1._1)))(
-                prevArgsCount => normalParamsInfosAndArgs.take(prevArgsCount).map(p => genVarRef(p._1._1)))
-
-          case arg => arg
-        }
-
-        js.Assign(genVarRef(param), newArg)
-      }
-
-      ifOverload(tree, js.Block(
-          inner ++ tree.ctor.beforeCall ++ captureAssigns ++ normalAssigns))
-    }
-
-    def postStats(tree: ConstructorTree[SplitSecondaryJSCtor]): js.Tree = {
-      val inner = tree.subCtors.map(postStats(_))
-      ifOverload(tree, js.Block(tree.ctor.afterCall ++ inner))
-    }
-
-    val primaryCtor = ctorTree.ctor
-    val secondaryCtorTrees = ctorTree.subCtors
-
-    wrapJSCtorBody(
-        secondaryCtorTrees.map(preStats(_, primaryCtor.paramsAndInfo)),
-        primaryCtor.body,
-        secondaryCtorTrees.map(postStats(_))
-    )
-  }
-
-  private def wrapJSCtorBody(before: List[js.Tree], body: js.JSConstructorBody,
-      after: List[js.Tree]): js.JSConstructorBody = {
-    js.JSConstructorBody(before ::: body.beforeSuper, body.superCall,
-        body.afterSuper ::: after)(body.pos)
-  }
-
-  private sealed trait JSCtor {
-    val sym: Symbol
-    val paramsAndInfo: List[(Symbol, JSParamInfo)]
-  }
-
-  private class PrimaryJSCtor(val sym: Symbol,
-      val paramsAndInfo: List[(Symbol, JSParamInfo)],
-      val body: js.JSConstructorBody) extends JSCtor
-
-  private class SplitSecondaryJSCtor(val sym: Symbol,
-      val paramsAndInfo: List[(Symbol, JSParamInfo)],
-      val beforeCall: List[js.Tree],
-      val targetCtor: Symbol, val ctorArgs: List[js.Tree],
-      val afterCall: List[js.Tree]) extends JSCtor
-
-  private class ConstructorTree[Ctor <: JSCtor](
-      val overloadNum: Int, val ctor: Ctor,
-      val subCtors: List[ConstructorTree[SplitSecondaryJSCtor]]) {
-    val lo: Int = overloadNum
-    val hi: Int = subCtors.lastOption.fold(lo)(_.hi)
-
-    assert(lo <= hi, "bad overload range")
-  }
-
-  // Generate a method -------------------------------------------------------
-
-  /** Generates the JSNativeMemberDef. */
-  def genJSNativeMemberDef(tree: ValOrDefDef): js.JSNativeMemberDef = {
-    implicit val pos = tree.span
-
-    val sym = tree.symbol
-    val flags = js.MemberFlags.empty.withNamespace(js.MemberNamespace.PublicStatic)
-    val methodName = encodeJSNativeMemberSym(sym)
-    val jsNativeLoadSpec = computeJSNativeLoadSpecOfValDef(sym)
-    js.JSNativeMemberDef(flags, methodName, jsNativeLoadSpec)
-  }
-
-  private def genMethod(dd: DefDef): Option[js.MethodDef] = {
-    withScopedVars(
-        localNames := new LocalNameGenerator
-    ) {
-      genMethodWithCurrentLocalNameScope(dd)
-    }
-  }
-
-  /** Gen JS code for a method definition in a class or in an impl class.
-   *  On the JS side, method names are mangled to encode the full signature
-   *  of the Scala method, as described in `JSEncoding`, to support
-   *  overloading.
-   *
-   *  Some methods are not emitted at all:
-   *  - Primitives, since they are never actually called
-   *  - Constructors of hijacked classes
-   *
-   *  Constructors are emitted by generating their body as a statement.
-   *
-   *  Other (normal) methods are emitted with `genMethodBody()`.
-   */
-  private def genMethodWithCurrentLocalNameScope(dd: DefDef): Option[js.MethodDef] = {
-    implicit val pos = dd.span
-    val sym = dd.symbol
-    val vparamss = dd.termParamss
-    val rhs = dd.rhs
-
-    /* Is this method a default accessor that should be ignored?
-     *
-     * This is the case iff one of the following applies:
-     * - It is a constructor default accessor and the linked class is a
-     *   native JS class.
-     * - It is a default accessor for a native JS def, but with the caveat
-     *   that its rhs must be `js.native` because of #4553.
-     *
-     * Both of those conditions can only happen if the default accessor is in
-     * a module class, so we use that as a fast way out. (But omitting that
-     * condition would not change the result.)
-     *
-     * This is different than `isJSDefaultParam` in `genApply`: we do not
-     * ignore default accessors of *non-native* JS types. Neither for
-     * constructor default accessor nor regular default accessors. We also
-     * do not need to worry about non-constructor members of native JS types,
-     * since for those, the entire member list is ignored in `genJSClassData`.
-     */
-    def isIgnorableDefaultParam: Boolean = {
-      sym.name.is(DefaultGetterName) && sym.owner.is(ModuleClass) && {
-        val info = new DefaultParamInfo(sym)
-        if (info.isForConstructor) {
-          /* This is a default accessor for a constructor parameter. Check
-           * whether the attached constructor is a native JS constructor,
-           * which is the case iff the linked class is a native JS type.
-           */
-          info.constructorOwner.hasAnnotation(jsdefn.JSNativeAnnot)
-        } else {
-          /* #4553 We need to ignore default accessors for JS native defs.
-           * However, because Scala.js <= 1.7.0 actually emitted code calling
-           * those accessors, we must keep default accessors that would
-           * compile. The only accessors we can actually get rid of are those
-           * that are `= js.native`.
-           */
-          !sym.owner.isJSType &&
-          info.attachedMethod.hasAnnotation(jsdefn.JSNativeAnnot) && {
-            dd.rhs match {
-              case MaybeAsInstanceOf(Apply(fun, _)) =>
-                fun.symbol == jsdefn.JSPackage_native
-              case _ =>
-                false
-            }
-          }
-        }
-      }
-    }
-
-    withPerMethodBodyState(sym) {
-      assert(vparamss.isEmpty || vparamss.tail.isEmpty,
-          "Malformed parameter list: " + vparamss)
-      val params = if (vparamss.isEmpty) Nil else vparamss.head.map(_.symbol)
-
-      val methodName = encodeMethodSym(sym)
-      val originalName = originalNameOfMethod(sym)
-
-      def jsParams = params.map(genParamDef(_))
-
-      if (primitives.isPrimitive(sym)) {
-        None
-      } else if (sym.is(Deferred) && currentClassSym.isNonNativeJSClass) {
-        // scala-js/#4409: Do not emit abstract methods in non-native JS classes
-        None
-      } else if (sym.is(Deferred)) {
-        Some(js.MethodDef(js.MemberFlags.empty, methodName, originalName,
-            jsParams, toIRType(patchedResultType(sym)), None)(
-            OptimizerHints.empty, None))
-      } else if (isIgnorableDefaultParam) {
-        // #11592
-        None
-      } else if (sym.is(Bridge) && sym.name.is(DefaultGetterName) && currentClassSym.isNonNativeJSClass) {
-        /* #12572 Bridges for default accessors in non-native JS classes must not be emitted,
-         * because they call another default accessor, making their entire body an
-         * <undefined-param> that cannot be eliminated.
-         * Such methods are never called anyway, because they are filtered out in
-         * JSExportsGen.defaultGetterDenot().
-         */
-        None
-      } else /*if (sym.isClassConstructor && isHijackedBoxedClass(sym.owner)) {
-        None
-      } else*/ {
-        /*def isTraitImplForwarder = dd.rhs match {
-          case app: Apply => foreignIsImplClass(app.symbol.owner)
-          case _          => false
-        }*/
-
-        val shouldMarkInline = {
-          sym.hasAnnotation(jsdefn.InlineAnnot) ||
-          sym.isAnonymousFunction
-        }
-
-        val shouldMarkNoinline = {
-          sym.hasAnnotation(jsdefn.NoinlineAnnot) /*&&
-          !isTraitImplForwarder*/
-        }
-
-        val optimizerHints = {
-          OptimizerHints.empty
-            .withInline(shouldMarkInline)
-            .withNoinline(shouldMarkNoinline)
-        }
-
-        val methodDef = {
-          if (sym.isClassConstructor) {
-            val namespace = js.MemberNamespace.Constructor
-            js.MethodDef(js.MemberFlags.empty.withNamespace(namespace),
-                methodName, originalName, jsParams, jstpe.NoType, Some(genStat(rhs)))(
-                optimizerHints, None)
-          } else {
-            val namespace = if (isMethodStaticInIR(sym)) {
-              if (sym.isPrivate) js.MemberNamespace.PrivateStatic
-              else js.MemberNamespace.PublicStatic
-            } else {
-              if (sym.isPrivate) js.MemberNamespace.Private
-              else js.MemberNamespace.Public
-            }
-            val resultIRType = toIRType(patchedResultType(sym))
-            genMethodDef(namespace, methodName, originalName,
-                params, resultIRType, rhs, optimizerHints)
-          }
-        }
-
-        Some(methodDef)
-      }
-    }
-  }
-
-  /** Generates the MethodDef of a (non-constructor) method
-   *
-   *  Most normal methods are emitted straightforwardly. If the result
-   *  type is Unit, then the body is emitted as a statement. Otherwise, it is
-   *  emitted as an expression.
-   *
-   *  Instance methods in non-native JS classes are compiled as static methods
-   *  taking an explicit parameter for their `this` value. Static methods in
-   *  non-native JS classes are compiled as is, like methods in Scala classes.
-   */
-  private def genMethodDef(namespace: js.MemberNamespace, methodName: js.MethodIdent,
-      originalName: OriginalName, paramsSyms: List[Symbol], resultIRType: jstpe.Type,
-      tree: Tree, optimizerHints: OptimizerHints): js.MethodDef = {
-    implicit val pos = tree.span
-
-    val jsParams = paramsSyms.map(genParamDef(_))
-
-    def genBody() = localNames.makeLabeledIfRequiresEnclosingReturn(resultIRType) {
-      if (resultIRType == jstpe.NoType) genStat(tree)
-      else genExpr(tree)
-    }
-
-    if (namespace.isStatic || !currentClassSym.isNonNativeJSClass) {
-      val flags = js.MemberFlags.empty.withNamespace(namespace)
-      js.MethodDef(flags, methodName, originalName, jsParams, resultIRType, Some(genBody()))(
-            optimizerHints, None)
-    } else {
-      val thisLocalIdent = freshLocalIdent("this")
-      withScopedVars(
-        thisLocalVarIdent := Some(thisLocalIdent)
-      ) {
-        val staticNamespace =
-          if (namespace.isPrivate) js.MemberNamespace.PrivateStatic
-          else js.MemberNamespace.PublicStatic
-        val flags =
-          js.MemberFlags.empty.withNamespace(staticNamespace)
-        val thisParamDef = js.ParamDef(thisLocalIdent, thisOriginalName,
-            jstpe.AnyType, mutable = false)
-
-        js.MethodDef(flags, methodName, originalName,
-            thisParamDef :: jsParams, resultIRType, Some(genBody()))(
-            optimizerHints, None)
-      }
-    }
-  }
-
-  // ParamDefs ---------------------------------------------------------------
-
-  def genParamDef(sym: Symbol): js.ParamDef =
-    genParamDef(sym, toIRType(sym.info))
-
-  private def genParamDef(sym: Symbol, ptpe: jstpe.Type): js.ParamDef =
-    genParamDef(sym, ptpe, sym.span)
-
-  private def genParamDef(sym: Symbol, pos: Position): js.ParamDef =
-    genParamDef(sym, toIRType(sym.info), pos)
-
-  private def genParamDef(sym: Symbol, ptpe: jstpe.Type, pos: Position): js.ParamDef = {
-    js.ParamDef(encodeLocalSym(sym)(implicitly, pos, implicitly),
-        originalNameOfLocal(sym), ptpe, mutable = false)(pos)
-  }
-
-  // Generate statements and expressions -------------------------------------
-
-  /** Gen JS code for a tree in statement position (in the IR).
-   */
-  private def genStat(tree: Tree): js.Tree = {
-    exprToStat(genStatOrExpr(tree, isStat = true))
-  }
-
-  /** Turn a JavaScript expression of type Unit into a statement */
-  private def exprToStat(tree: js.Tree): js.Tree = {
-    /* Any JavaScript expression is also a statement, but at least we get rid
-     * of some pure expressions that come from our own codegen.
-     */
-    implicit val pos = tree.pos
-    tree match {
-      case js.Block(stats :+ expr) =>
-        js.Block(stats :+ exprToStat(expr))
-      case _:js.Literal | _:js.This | _:js.VarRef =>
-        js.Skip()
-      case _ =>
-        tree
-    }
-  }
-
-  /** Gen JS code for a tree in expression position (in the IR).
-   */
-  private def genExpr(tree: Tree): js.Tree = {
-    val result = genStatOrExpr(tree, isStat = false)
-    assert(result.tpe != jstpe.NoType,
-        s"genExpr($tree) returned a tree with type NoType at pos ${tree.span}")
-    result
-  }
-
-  def genExpr(name: JSName)(implicit pos: SourcePosition): js.Tree = name match {
-    case JSName.Literal(name) => js.StringLiteral(name)
-    case JSName.Computed(sym) => genComputedJSName(sym)
-  }
-
-  private def genComputedJSName(sym: Symbol)(implicit pos: SourcePosition): js.Tree = {
-    /* By construction (i.e. restriction in PrepJSInterop), we know that sym
-     * must be a static method.
-     * Therefore, at this point, we can invoke it by loading its owner and
-     * calling it.
-     */
-    def moduleOrGlobalScope = genLoadModuleOrGlobalScope(sym.owner)
-    def module = genLoadModule(sym.owner)
-
-    if (sym.owner.isJSType) {
-      if (!sym.owner.isNonNativeJSClass || sym.isJSExposed)
-        genApplyJSMethodGeneric(sym, moduleOrGlobalScope, args = Nil, isStat = false)
-      else
-        genApplyJSClassMethod(module, sym, arguments = Nil)
-    } else {
-      genApplyMethod(module, sym, arguments = Nil)
-    }
-  }
-
-  /** Gen JS code for a tree in expression position (in the IR) or the
-   *  global scope.
-   */
-  def genExprOrGlobalScope(tree: Tree): MaybeGlobalScope = {
-    implicit def pos: SourcePosition = tree.sourcePos
-
-    tree match {
-      case _: This =>
-        val sym = tree.symbol
-        if (sym != currentClassSym.get && sym.is(Module))
-          genLoadModuleOrGlobalScope(sym)
-        else
-          MaybeGlobalScope.NotGlobalScope(genExpr(tree))
-
-      case _:Ident | _:Select =>
-        val sym = tree.symbol
-        if (sym.is(Module)) {
-          assert(!sym.is(PackageClass), "Cannot use package as value: " + tree)
-          genLoadModuleOrGlobalScope(sym)
-        } else {
-          MaybeGlobalScope.NotGlobalScope(genExpr(tree))
-        }
-
-      case Apply(fun, _) =>
-        if (fun.symbol == jsdefn.JSDynamic_global)
-          MaybeGlobalScope.GlobalScope(pos)
-        else
-          MaybeGlobalScope.NotGlobalScope(genExpr(tree))
-
-      case _ =>
-        MaybeGlobalScope.NotGlobalScope(genExpr(tree))
-    }
-  }
-
-  /** Gen JS code for a tree in statement or expression position (in the IR).
-   *
-   *  This is the main transformation method. Each node of the Scala AST
-   *  is transformed into an equivalent portion of the JS AST.
-   */
-  private def genStatOrExpr(tree: Tree, isStat: Boolean): js.Tree = {
-    implicit val pos: SourcePosition = tree.sourcePos
-
-    report.debuglog("  " + tree)
-    report.debuglog("")
-
-    tree match {
-      /** Local val or var declaration */
-      case tree @ ValDef(name, _, _) =>
-        val sym = tree.symbol
-        val rhs = tree.rhs
-        val rhsTree = genExpr(rhs)
-
-        rhsTree match {
-          case js.Transient(UndefinedParam) =>
-            /* This is an intermediate assignment for default params on a
-             * js.Any. Add the symbol to the corresponding set to inform
-             * the Ident resolver how to replace it and don't emit the symbol.
-             */
-            undefinedDefaultParams += sym
-            js.Skip()
-          case _ =>
-            js.VarDef(encodeLocalSym(sym), originalNameOfLocal(sym),
-                toIRType(sym.info), sym.is(Mutable), rhsTree)
-        }
-
-      case If(cond, thenp, elsep) =>
-        val tpe =
-          if (isStat) jstpe.NoType
-          else toIRType(tree.tpe)
-
-        js.If(genExpr(cond), genStatOrExpr(thenp, isStat),
-            genStatOrExpr(elsep, isStat))(tpe)
-
-      case Labeled(bind, expr) =>
-        js.Labeled(encodeLabelSym(bind.symbol), toIRType(tree.tpe), genStatOrExpr(expr, isStat))
-
-      case Return(expr, from) =>
-        val fromSym = from.symbol
-        val label =
-          if (fromSym.is(Label)) encodeLabelSym(fromSym)
-          else localNames.get.getEnclosingReturnLabel()
-        js.Return(toIRType(expr.tpe) match {
-          case jstpe.NoType => js.Block(genStat(expr), js.Undefined())
-          case _            => genExpr(expr)
-        }, label)
-
-      case WhileDo(cond, body) =>
-        val genCond =
-          if (cond == EmptyTree) js.BooleanLiteral(true)
-          else genExpr(cond)
-        js.While(genCond, genStat(body))
-
-      case t: Try =>
-        genTry(t, isStat)
-
-      case app: Apply =>
-        genApply(app, isStat)
-
-      case app: TypeApply =>
-        genTypeApply(app)
-
-      /*case app: ApplyDynamic =>
-        genApplyDynamic(app)*/
-
-      case tree: This =>
-        val currentClass = currentClassSym.get
-        val symIsModuleClass = tree.symbol.is(ModuleClass)
-        assert(tree.symbol == currentClass || symIsModuleClass,
-            s"Trying to access the this of another class: tree.symbol = ${tree.symbol}, class symbol = $currentClass")
-        if (symIsModuleClass && tree.symbol != currentClass)
-          genLoadModule(tree.symbol)
-        else
-          genThis()
-
-      case Select(qualifier, _) =>
-        val sym = tree.symbol
-        if (sym.is(Module)) {
-          assert(!sym.is(Package), "Cannot use package as value: " + tree)
-          genLoadModule(sym)
-        } else if (sym.is(JavaStatic)) {
-          genLoadStaticField(sym)
-        } else if (sym.hasAnnotation(jsdefn.JSNativeAnnot)) {
-          genJSNativeMemberSelect(tree)
-        } else {
-          val (field, boxed) = genAssignableField(sym, qualifier)
-          if (boxed) unbox(field, atPhase(elimErasedValueTypePhase)(sym.info))
-          else field
-        }
-
-      case tree: Ident =>
-        desugarIdent(tree).fold[js.Tree] {
-          val sym = tree.symbol
-          assert(!sym.is(Package), "Cannot use package as value: " + tree)
-          if (sym.is(Module)) {
-            genLoadModule(sym)
-          } else if (undefinedDefaultParams.contains(sym)) {
-            /* This is a default parameter whose assignment was moved to
-             * a local variable. Put an undefined param instead.
-             */
-            js.Transient(UndefinedParam)
-          } else {
-            genVarRef(sym)
-          }
-        } { select =>
-          genStatOrExpr(select, isStat)
-        }
-
-      case Literal(value) =>
-        import Constants._
-        value.tag match {
-          case UnitTag =>
-            js.Skip()
-          case BooleanTag =>
-            js.BooleanLiteral(value.booleanValue)
-          case ByteTag =>
-            js.ByteLiteral(value.byteValue)
-          case ShortTag =>
-            js.ShortLiteral(value.shortValue)
-          case CharTag =>
-            js.CharLiteral(value.charValue)
-          case IntTag =>
-            js.IntLiteral(value.intValue)
-          case LongTag =>
-            js.LongLiteral(value.longValue)
-          case FloatTag =>
-            js.FloatLiteral(value.floatValue)
-          case DoubleTag =>
-            js.DoubleLiteral(value.doubleValue)
-          case StringTag =>
-            js.StringLiteral(value.stringValue)
-          case NullTag =>
-            js.Null()
-          case ClazzTag =>
-            genClassConstant(value.typeValue)
-        }
-
-      case Block(stats, expr) =>
-        // #15419 Collapse { <undefined-param>; BoxedUnit } to <undefined-param>
-        val genStatsAndExpr0 = stats.map(genStat(_)) :+ genStatOrExpr(expr, isStat)
-        val genStatsAndExpr = genStatsAndExpr0 match {
-          case (undefParam @ js.Transient(UndefinedParam)) :: js.Undefined() :: Nil =>
-            undefParam :: Nil
-          case _ =>
-            genStatsAndExpr0
-        }
-        js.Block(genStatsAndExpr)
-
-      case Typed(expr, _) =>
-        expr match {
-          case _: Super => genThis()
-          case _        => genExpr(expr)
-        }
-
-      case Assign(lhs0, rhs) =>
-        val sym = lhs0.symbol
-        if (sym.is(JavaStaticTerm) && sym.source != ctx.compilationUnit.source)
-          throw new FatalError(s"Assignment to static member ${sym.fullName} not supported")
-        def genRhs = genExpr(rhs)
-        val lhs = lhs0 match {
-          case lhs: Ident => desugarIdent(lhs).getOrElse(lhs)
-          case lhs => lhs
-        }
-        lhs match {
-          case lhs: Select =>
-            val qualifier = lhs.qualifier
-
-            def ctorAssignment = (
-                currentMethodSym.get.name == nme.CONSTRUCTOR &&
-                currentMethodSym.get.owner == qualifier.symbol &&
-                qualifier.isInstanceOf[This]
-            )
-            // TODO This fails for OFFSET$x fields. Re-enable when we can.
-            /*if (!sym.is(Mutable) && !ctorAssignment)
-              throw new FatalError(s"Assigning to immutable field ${sym.fullName} at $pos")*/
-
-            if (sym.hasAnnotation(jsdefn.JSNativeAnnot)) {
-              /* This is an assignment to a @js.native field. Since we reject
-               * `@js.native var`s as compile errors, this can only happen in
-               * the constructor of the enclosing object.
-               * We simply ignore the assignment, since the field will not be
-               * emitted at all.
-               */
-              js.Skip()
-            } else {
-              val (field, boxed) = genAssignableField(sym, qualifier)
-              if (boxed) {
-                val genBoxedRhs = box(genRhs, atPhase(elimErasedValueTypePhase)(sym.info))
-                js.Assign(field, genBoxedRhs)
-              } else {
-                js.Assign(field, genRhs)
-              }
-            }
-
-          case _ =>
-            js.Assign(genVarRef(sym), genRhs)
-        }
-
-      /** Array constructor */
-      case javaSeqLiteral: JavaSeqLiteral =>
-        genJavaSeqLiteral(javaSeqLiteral)
-
-      /** A Match reaching the backend is supposed to be optimized as a switch */
-      case mtch: Match =>
-        genMatch(mtch, isStat)
-
-      case tree: Closure =>
-        genClosure(tree)
-
-      case EmptyTree =>
-        js.Skip()
-
-      case _ =>
-        throw new FatalError("Unexpected tree in genExpr: " +
-            tree + "/" + tree.getClass + " at: " + (tree.span: Position))
-    }
-  } // end of genStatOrExpr()
-
-  private def qualifierOf(fun: Tree): Tree = fun match {
-    case fun: Ident =>
-      fun.tpe match {
-        case TermRef(prefix: TermRef, _) => tpd.ref(prefix)
-        case TermRef(prefix: ThisType, _) => tpd.This(prefix.cls)
-      }
-    case Select(qualifier, _) =>
-      qualifier
-    case TypeApply(fun, _) =>
-      qualifierOf(fun)
-  }
-
-  /** Gen JS this of the current class.
-   *  Normally encoded straightforwardly as a JS this.
-   *  But must be replaced by the `thisLocalVarIdent` local variable if there
-   *  is one.
-   */
-  private def genThis()(implicit pos: Position): js.Tree = {
-    /*if (tryingToGenMethodAsJSFunction) {
-      throw new CancelGenMethodAsJSFunction(
-          "Trying to generate `this` inside the body")
-    }*/
-
-    thisLocalVarIdent.fold[js.Tree] {
-      js.This()(currentThisType)
-    } { thisLocalIdent =>
-      js.VarRef(thisLocalIdent)(currentThisType)
-    }
-  }
-
-  /** Gen IR code for a `try..catch` or `try..finally` block.
-   *
-   *  `try..finally` blocks are compiled straightforwardly to `try..finally`
-   *  blocks of the IR.
-   *
-   *  `try..catch` blocks are a bit more subtle, as the IR does not have
-   *  type-based selection of exceptions to catch. We thus encode explicitly
-   *  the type tests, like in:
-   *
-   *  ```
-   *  try { ... }
-   *  catch (e) {
-   *    if (e.isInstanceOf[IOException]) { ... }
-   *    else if (e.isInstanceOf[Exception]) { ... }
-   *    else {
-   *      throw e; // default, re-throw
-   *    }
-   *  }
-   *  ```
-   *
-   *  In addition, there are provisions to handle catching JavaScript
-   *  exceptions (which do not extend `Throwable`) as wrapped in a
-   *  `js.JavaScriptException`.
-   */
-  private def genTry(tree: Try, isStat: Boolean): js.Tree = {
-    implicit val pos: SourcePosition = tree.sourcePos
-    val Try(block, catches, finalizer) = tree
-
-    val blockAST = genStatOrExpr(block, isStat)
-
-    val resultType =
-      if (isStat) jstpe.NoType
-      else toIRType(tree.tpe)
-
-    val handled =
-      if (catches.isEmpty) blockAST
-      else genTryCatch(blockAST, catches, resultType, isStat)
-
-    genStat(finalizer) match {
-      case js.Skip() => handled
-      case ast       => js.TryFinally(handled, ast)
-    }
-  }
-
-  private def genTryCatch(body: js.Tree, catches: List[CaseDef],
-      resultType: jstpe.Type,
-      isStat: Boolean)(implicit pos: SourcePosition): js.Tree = {
-    val exceptIdent = freshLocalIdent("e")
-    val origExceptVar = js.VarRef(exceptIdent)(jstpe.AnyType)
-
-    val mightCatchJavaScriptException = catches.exists { caseDef =>
-      caseDef.pat match {
-        case Typed(Ident(nme.WILDCARD), tpt) =>
-          isMaybeJavaScriptException(tpt.tpe)
-        case Ident(nme.WILDCARD) =>
-          true
-        case pat @ Bind(_, _) =>
-          isMaybeJavaScriptException(pat.symbol.info)
-      }
-    }
-
-    val (exceptValDef, exceptVar) = if (mightCatchJavaScriptException) {
-      val valDef = js.VarDef(freshLocalIdent("e"), NoOriginalName,
-          encodeClassType(defn.ThrowableClass), mutable = false, js.WrapAsThrowable(origExceptVar))
-      (valDef, valDef.ref)
-    } else {
-      (js.Skip(), origExceptVar)
-    }
-
-    val elseHandler: js.Tree = js.Throw(origExceptVar)
-
-    val handler = catches.foldRight(elseHandler) { (caseDef, elsep) =>
-      implicit val pos: SourcePosition = caseDef.sourcePos
-      val CaseDef(pat, _, body) = caseDef
-
-      // Extract exception type and variable
-      val (tpe, boundVar) = (pat match {
-        case Typed(Ident(nme.WILDCARD), tpt) =>
-          (tpt.tpe, None)
-        case Ident(nme.WILDCARD) =>
-          (defn.ThrowableType, None)
-        case Bind(_, _) =>
-          val ident = encodeLocalSym(pat.symbol)
-          val origName = originalNameOfLocal(pat.symbol)
-          (pat.symbol.info, Some(ident, origName))
-      })
-
-      // Generate the body that must be executed if the exception matches
-      val bodyWithBoundVar = (boundVar match {
-        case None =>
-          genStatOrExpr(body, isStat)
-        case Some((boundVarIdent, boundVarOriginalName)) =>
-          val castException = genAsInstanceOf(exceptVar, tpe)
-          js.Block(
-              js.VarDef(boundVarIdent, boundVarOriginalName, toIRType(tpe),
-                  mutable = false, castException),
-              genStatOrExpr(body, isStat))
-      })
-
-      // Generate the test
-      if (tpe =:= defn.ThrowableType) {
-        bodyWithBoundVar
-      } else {
-        val cond = genIsInstanceOf(exceptVar, tpe)
-        js.If(cond, bodyWithBoundVar, elsep)(resultType)
-      }
-    }
-
-    js.TryCatch(body, exceptIdent, NoOriginalName,
-        js.Block(exceptValDef, handler))(resultType)
-  }
-
-  /** Gen JS code for an Apply node (method call)
-   *
-   *  There's a whole bunch of varieties of Apply nodes: regular method
-   *  calls, super calls, constructor calls, isInstanceOf/asInstanceOf,
-   *  primitives, JS calls, etc. They are further dispatched in here.
-   */
-  private def genApply(tree: Apply, isStat: Boolean): js.Tree = {
-    implicit val pos = tree.span
-    val args = tree.args
-    val sym = tree.fun.symbol
-
-    /* Is the method a JS default accessor, which should become an
-     * `UndefinedParam` rather than being compiled normally.
-     *
-     * This is true iff one of the following conditions apply:
-     * - It is a constructor default param for the constructor of a JS class.
-     * - It is a default param of an instance method of a native JS type.
-     * - It is a default param of an instance method of a non-native JS type
-     *   and the attached method is exposed.
-     * - It is a default param for a native JS def.
-     *
-     * This is different than `isIgnorableDefaultParam` in
-     * `genMethodWithCurrentLocalNameScope`: we include here the default
-     * accessors of *non-native* JS types (unless the corresponding methods are
-     * not exposed). We also need to handle non-constructor members of native
-     * JS types.
-     */
-    def isJSDefaultParam: Boolean = {
-      sym.name.is(DefaultGetterName) && {
-        val info = new DefaultParamInfo(sym)
-        if (info.isForConstructor) {
-          /* This is a default accessor for a constructor parameter. Check
-           * whether the attached constructor is a JS constructor, which is
-           * the case iff the linked class is a JS type.
-           */
-          info.constructorOwner.isJSType
-        } else {
-          if (sym.owner.isJSType) {
-            /* The default accessor is in a JS type. It is a JS default
-             * param iff the enclosing class is native or the attached method
-             * is exposed.
-             */
-            !sym.owner.isNonNativeJSClass || info.attachedMethod.isJSExposed
-          } else {
-            /* The default accessor is in a Scala type. It is a JS default
-             * param iff the attached method is a native JS def. This can
-             * only happen if the owner is a module class, which we test
-             * first as a fast way out.
-             */
-            sym.owner.is(ModuleClass) && info.attachedMethod.hasAnnotation(jsdefn.JSNativeAnnot)
-          }
-        }
-      }
-    }
-
-    tree.fun match {
-      case _ if isJSDefaultParam =>
-        js.Transient(UndefinedParam)
-
-      case Select(Super(_, _), _) =>
-        genSuperCall(tree, isStat)
-
-      case Select(New(_), nme.CONSTRUCTOR) =>
-        genApplyNew(tree)
-
-      case _ =>
-        if (primitives.isPrimitive(tree)) {
-          genPrimitiveOp(tree, isStat)
-        } else if (Erasure.Boxing.isBox(sym)) {
-          // Box a primitive value (cannot be Unit)
-          val arg = args.head
-          makePrimitiveBox(genExpr(arg), arg.tpe)
-        } else if (Erasure.Boxing.isUnbox(sym)) {
-          // Unbox a primitive value (cannot be Unit)
-          val arg = args.head
-          makePrimitiveUnbox(genExpr(arg), tree.tpe)
-        } else {
-          genNormalApply(tree, isStat)
-        }
-    }
-  }
-
-  /** Gen JS code for a super call, of the form Class.super[mix].fun(args).
-   *
-   *  This does not include calls defined in mixin traits, as these are
-   *  already desugared by the 'mixin' phase. Only calls to super classes
-   *  remain.
-   *
-   *  Since a class has exactly one direct superclass, and calling a method
-   *  two classes above the current one is invalid in Scala, the `mix` item is
-   *  irrelevant.
-   */
-  private def genSuperCall(tree: Apply, isStat: Boolean): js.Tree = {
-    implicit val pos = tree.span
-    val Apply(fun @ Select(sup @ Super(qual, _), _), args) = tree: @unchecked
-    val sym = fun.symbol
-
-    if (sym == defn.Any_getClass) {
-      // The only primitive that is also callable as super call
-      js.GetClass(genThis())
-    } else if (currentClassSym.isNonNativeJSClass) {
-      genJSSuperCall(tree, isStat)
-    } else {
-      /* #3013 `qual` can be `this.$outer()` in some cases since Scala 2.12,
-       * so we call `genExpr(qual)`, not just `genThis()`.
-       */
-      val superCall = genApplyMethodStatically(
-          genExpr(qual), sym, genActualArgs(sym, args))
-
-      // Initialize the module instance just after the super constructor call.
-      if (isStaticModule(currentClassSym) && !isModuleInitialized.get.value &&
-          currentMethodSym.get.isClassConstructor) {
-        isModuleInitialized.get.value = true
-        val className = encodeClassName(currentClassSym)
-        val thisType = jstpe.ClassType(className)
-        val initModule = js.StoreModule(className, js.This()(thisType))
-        js.Block(superCall, initModule)
-      } else {
-        superCall
-      }
-    }
-  }
-
-  /** Gen JS code for a constructor call (new).
-   *  Further refined into:
-   *  * new String(...)
-   *  * new of a hijacked boxed class
-   *  * new of an anonymous function class that was recorded as JS function
-   *  * new of a raw JS class
-   *  * new Array
-   *  * regular new
-   */
-  private def genApplyNew(tree: Apply): js.Tree = {
-    implicit val pos: SourcePosition = tree.sourcePos
-
-    val Apply(fun @ Select(New(tpt), nme.CONSTRUCTOR), args) = tree: @unchecked
-    val ctor = fun.symbol
-    val tpe = tpt.tpe
-
-    assert(ctor.isClassConstructor,
-        "'new' call to non-constructor: " + ctor.name)
-
-    val clsSym = tpe.typeSymbol
-
-    if (isHijackedClass(clsSym)) {
-      genNewHijackedClass(clsSym, ctor, args.map(genExpr))
-    } else /*if (translatedAnonFunctions contains tpe.typeSymbol) {
-      val functionMaker = translatedAnonFunctions(tpe.typeSymbol)
-      functionMaker(args map genExpr)
-    } else*/ if (clsSym.isJSType) {
-      genNewJSClass(tree)
-    } else {
-      toTypeRef(tpe) match {
-        case jstpe.ClassRef(className) =>
-          js.New(className, encodeMethodSym(ctor), genActualArgs(ctor, args))
-
-        case other =>
-          throw new FatalError(s"Non ClassRef cannot be instantiated: $other")
-      }
-    }
-  }
-
-  /** Gen JS code for a call to a constructor of a hijacked class.
-   *  Reroute them to the `new` method with the same signature in the
-   *  companion object.
-   */
-  private def genNewHijackedClass(clazz: Symbol, ctor: Symbol,
-      args: List[js.Tree])(implicit pos: SourcePosition): js.Tree = {
-
-    val className = encodeClassName(clazz)
-    val initName = encodeMethodSym(ctor).name
-    val newName = MethodName(newSimpleMethodName, initName.paramTypeRefs,
-        jstpe.ClassRef(className))
-    val newMethodIdent = js.MethodIdent(newName)
-
-    js.ApplyStatic(js.ApplyFlags.empty, className, newMethodIdent, args)(
-        jstpe.ClassType(className))
-  }
-
-  /** Gen JS code for a new of a JS class (subclass of `js.Any`). */
-  private def genNewJSClass(tree: Apply): js.Tree = {
-    acquireContextualJSClassValue { jsClassValue =>
-      implicit val pos: Position = tree.span
-
-      val Apply(fun @ Select(New(tpt), _), args) = tree: @unchecked
-      val cls = tpt.tpe.typeSymbol
-      val ctor = fun.symbol
-
-      val nestedJSClass = cls.isNestedJSClass
-      assert(jsClassValue.isDefined == nestedJSClass,
-          s"$cls at $pos: jsClassValue.isDefined = ${jsClassValue.isDefined} " +
-          s"but isInnerNonNativeJSClass = $nestedJSClass")
-
-      def genArgs: List[js.TreeOrJSSpread] = genActualJSArgs(ctor, args)
-      def genArgsAsClassCaptures: List[js.Tree] = args.map(genExpr)
-
-      jsClassValue.fold {
-        // Static JS class (by construction, it cannot be a module class, as their News do not reach the back-end)
-        if (cls == jsdefn.JSObjectClass && args.isEmpty)
-          js.JSObjectConstr(Nil)
-        else if (cls == jsdefn.JSArrayClass && args.isEmpty)
-          js.JSArrayConstr(Nil)
-        else
-          js.JSNew(genLoadJSConstructor(cls), genArgs)
-      } { jsClassVal =>
-        // Nested JS class
-        if (cls.isAnonymousClass)
-          genNewAnonJSClass(cls, jsClassVal, genArgsAsClassCaptures)(fun.span)
-        else if (atPhase(erasurePhase)(cls.is(ModuleClass))) // LambdaLift removes the ModuleClass flag of lifted classes
-          js.JSNew(js.CreateJSClass(encodeClassName(cls), jsClassVal :: genArgsAsClassCaptures), Nil)
-        else
-          js.JSNew(jsClassVal, genArgs)
-      }
-    }
-  }
-
-  /** Generate an instance of an anonymous (non-lambda) JS class inline
-   *
-   *  @param sym Class to generate the instance of
-   *  @param jsSuperClassValue JS class value of the super class
-   *  @param args Arguments to the Scala constructor, which map to JS class captures
-   *  @param pos Position of the original New tree
-   */
-  private def genNewAnonJSClass(sym: Symbol, jsSuperClassValue: js.Tree, args: List[js.Tree])(
-      implicit pos: Position): js.Tree = {
-    assert(sym.isAnonymousClass,
-        s"Generating AnonJSClassNew of non anonymous JS class ${sym.fullName}")
-
-    // Find the TypeDef for this anonymous class and generate it
-    val typeDef = consumeLazilyGeneratedAnonClass(sym)
-    val originalClassDef = resetAllScopedVars {
-      withScopedVars(
-          currentClassSym := sym
-      ) {
-        genNonNativeJSClass(typeDef)
-      }
-    }
-
-    // Partition class members.
-    val privateFieldDefs = mutable.ListBuffer.empty[js.FieldDef]
-    val classDefMembers = mutable.ListBuffer.empty[js.MemberDef]
-    val instanceMembers = mutable.ListBuffer.empty[js.MemberDef]
-    var constructor: Option[js.JSConstructorDef] = None
-
-    originalClassDef.memberDefs.foreach {
-      case fdef: js.FieldDef =>
-        privateFieldDefs += fdef
-
-      case fdef: js.JSFieldDef =>
-        instanceMembers += fdef
-
-      case mdef: js.MethodDef =>
-        assert(mdef.flags.namespace.isStatic,
-            "Non-static, unexported method in non-native JS class")
-        classDefMembers += mdef
-
-      case cdef: js.JSConstructorDef =>
-        assert(constructor.isEmpty, "two ctors in class")
-        constructor = Some(cdef)
-
-      case mdef: js.JSMethodDef =>
-        assert(!mdef.flags.namespace.isStatic, "Exported static method")
-        instanceMembers += mdef
-
-      case property: js.JSPropertyDef =>
-        instanceMembers += property
-
-      case nativeMemberDef: js.JSNativeMemberDef =>
-        throw new FatalError("illegal native JS member in JS class at " + nativeMemberDef.pos)
-    }
-
-    assert(originalClassDef.topLevelExportDefs.isEmpty,
-        "Found top-level exports in anonymous JS class at " + pos)
-
-    // Make new class def with static members
-    val newClassDef = {
-      implicit val pos = originalClassDef.pos
-      val parent = js.ClassIdent(jsNames.ObjectClass)
-      js.ClassDef(originalClassDef.name, originalClassDef.originalName,
-          ClassKind.AbstractJSType, None, Some(parent), interfaces = Nil,
-          jsSuperClass = None, jsNativeLoadSpec = None,
-          classDefMembers.toList, Nil)(
-          originalClassDef.optimizerHints)
-    }
-
-    generatedClasses += newClassDef
-
-    // Construct inline class definition
-
-    val jsClassCaptures = originalClassDef.jsClassCaptures.getOrElse {
-      throw new AssertionError(s"no class captures for anonymous JS class at $pos")
-    }
-    val js.JSConstructorDef(_, ctorParams, ctorRestParam, ctorBody) = constructor.getOrElse {
-      throw new AssertionError("No ctor found")
-    }
-    assert(ctorParams.isEmpty && ctorRestParam.isEmpty,
-        s"non-empty constructor params for anonymous JS class at $pos")
-
-    /* The first class capture is always a reference to the super class.
-     * This is enforced by genJSClassCapturesAndConstructor.
-     */
-    def jsSuperClassRef(implicit pos: ir.Position): js.VarRef =
-      jsClassCaptures.head.ref
-
-    /* The `this` reference.
-     * FIXME This could clash with a local variable of the constructor or a JS
-     * class capture. It seems Scala 2 has the same vulnerability. How do we
-     * avoid this?
-     */
-    val selfName = freshLocalIdent("this")(pos)
-    def selfRef(implicit pos: ir.Position) =
-      js.VarRef(selfName)(jstpe.AnyType)
-
-    def memberLambda(params: List[js.ParamDef], restParam: Option[js.ParamDef], body: js.Tree)(implicit pos: ir.Position): js.Closure =
-      js.Closure(arrow = false, captureParams = Nil, params, restParam, body, captureValues = Nil)
-
-    val memberDefinitions0 = instanceMembers.toList.map {
-      case fdef: js.FieldDef =>
-        throw new AssertionError("unexpected FieldDef")
-
-      case fdef: js.JSFieldDef =>
-        implicit val pos = fdef.pos
-        js.Assign(js.JSSelect(selfRef, fdef.name), jstpe.zeroOf(fdef.ftpe))
-
-      case mdef: js.MethodDef =>
-        throw new AssertionError("unexpected MethodDef")
-
-      case cdef: js.JSConstructorDef =>
-        throw new AssertionError("unexpected JSConstructorDef")
-
-      case mdef: js.JSMethodDef =>
-        implicit val pos = mdef.pos
-        val impl = memberLambda(mdef.args, mdef.restParam, mdef.body)
-        js.Assign(js.JSSelect(selfRef, mdef.name), impl)
-
-      case pdef: js.JSPropertyDef =>
-        implicit val pos = pdef.pos
-        val optGetter = pdef.getterBody.map { body =>
-          js.StringLiteral("get") -> memberLambda(params = Nil, restParam = None, body)
-        }
-        val optSetter = pdef.setterArgAndBody.map { case (arg, body) =>
-          js.StringLiteral("set") -> memberLambda(params = arg :: Nil, restParam = None, body)
-        }
-        val descriptor = js.JSObjectConstr(
-            optGetter.toList :::
-            optSetter.toList :::
-            List(js.StringLiteral("configurable") -> js.BooleanLiteral(true))
-        )
-        js.JSMethodApply(js.JSGlobalRef("Object"),
-            js.StringLiteral("defineProperty"),
-            List(selfRef, pdef.name, descriptor))
-
-      case nativeMemberDef: js.JSNativeMemberDef =>
-        throw new FatalError("illegal native JS member in JS class at " + nativeMemberDef.pos)
-    }
-
-    val memberDefinitions = if (privateFieldDefs.isEmpty) {
-      memberDefinitions0
-    } else {
-      /* Private fields, declared in FieldDefs, are stored in a separate
-       * object, itself stored as a non-enumerable field of the `selfRef`.
-       * The name of that field is retrieved at
-       * `scala.scalajs.runtime.privateFieldsSymbol()`, and is a Symbol if
-       * supported, or a randomly generated string that has the same enthropy
-       * as a UUID (i.e., 128 random bits).
-       *
-       * This encoding solves two issues:
-       *
-       * - Hide private fields in anonymous JS classes from `JSON.stringify`
-       *   and other cursory inspections in JS (#2748).
-       * - Get around the fact that abstract JS types cannot declare
-       *   FieldDefs (#3777).
-       */
-      val fieldsObjValue = {
-        js.JSObjectConstr(privateFieldDefs.toList.map { fdef =>
-          implicit val pos = fdef.pos
-          js.StringLiteral(fdef.name.name.nameString) -> jstpe.zeroOf(fdef.ftpe)
-        })
-      }
-      val definePrivateFieldsObj = {
-        /* Object.defineProperty(selfRef, privateFieldsSymbol, {
-         *   value: fieldsObjValue
-         * });
-         *
-         * `writable`, `configurable` and `enumerable` are false by default.
-         */
-        js.JSMethodApply(
-            js.JSGlobalRef("Object"),
-            js.StringLiteral("defineProperty"),
-            List(
-                selfRef,
-                genPrivateFieldsSymbol()(using sym.sourcePos),
-                js.JSObjectConstr(List(
-                    js.StringLiteral("value") -> fieldsObjValue
-                ))
-            )
-        )
-      }
-      definePrivateFieldsObj :: memberDefinitions0
-    }
-
-    // Transform the constructor body.
-    val inlinedCtorStats: List[js.Tree] = {
-      val beforeSuper = ctorBody.beforeSuper
-
-      val superCall = {
-        implicit val pos = ctorBody.superCall.pos
-        val js.JSSuperConstructorCall(args) = ctorBody.superCall
-
-        val newTree = {
-          val ident = originalClassDef.superClass.getOrElse(throw new FatalError("No superclass"))
-          if (args.isEmpty && ident.name == JSObjectClassName)
-            js.JSObjectConstr(Nil)
-          else
-            js.JSNew(jsSuperClassRef, args)
-        }
-
-        val selfVarDef = js.VarDef(selfName, thisOriginalName, jstpe.AnyType, mutable = false, newTree)
-        selfVarDef :: memberDefinitions
-      }
-
-      // After the super call, substitute `selfRef` for `This()`
-      val afterSuper = new ir.Transformers.Transformer {
-        override def transform(tree: js.Tree, isStat: Boolean): js.Tree = tree match {
-          case js.This() =>
-            selfRef(tree.pos)
-
-          // Don't traverse closure boundaries
-          case closure: js.Closure =>
-            val newCaptureValues = closure.captureValues.map(transformExpr)
-            closure.copy(captureValues = newCaptureValues)(closure.pos)
-
-          case tree =>
-            super.transform(tree, isStat)
-        }
-      }.transformStats(ctorBody.afterSuper)
-
-      beforeSuper ::: superCall ::: afterSuper
-    }
-
-    val closure = js.Closure(arrow = true, jsClassCaptures, Nil, None,
-        js.Block(inlinedCtorStats, selfRef), jsSuperClassValue :: args)
-    js.JSFunctionApply(closure, Nil)
-  }
-
-  /** Gen JS code for a primitive method call. */
-  private def genPrimitiveOp(tree: Apply, isStat: Boolean): js.Tree = {
-    import dotty.tools.backend.ScalaPrimitivesOps._
-
-    implicit val pos = tree.span
-
-    val Apply(fun, args) = tree
-    val receiver = qualifierOf(fun)
-
-    val code = primitives.getPrimitive(tree, receiver.tpe)
-
-    if (isArithmeticOp(code) || isLogicalOp(code) || isComparisonOp(code))
-      genSimpleOp(tree, receiver :: args, code)
-    else if (code == CONCAT)
-      genStringConcat(tree, receiver, args)
-    else if (code == HASH)
-      genScalaHash(tree, receiver)
-    else if (isArrayOp(code))
-      genArrayOp(tree, code)
-    else if (code == SYNCHRONIZED)
-      genSynchronized(tree, isStat)
-    else if (isCoercion(code))
-      genCoercion(tree, receiver, code)
-    else if (code == JSPrimitives.THROW)
-      genThrow(tree, args)
-    else if (JSPrimitives.isJSPrimitive(code))
-      genJSPrimitive(tree, args, code, isStat)
-    else
-      throw new FatalError(s"Unknown primitive: ${tree.symbol.fullName} at: $pos")
-  }
-
-  /** Gen JS code for a simple operation (arithmetic, logical, or comparison) */
-  private def genSimpleOp(tree: Apply, args: List[Tree], code: Int): js.Tree = {
-    args match {
-      case List(arg)      => genSimpleUnaryOp(tree, arg, code)
-      case List(lhs, rhs) => genSimpleBinaryOp(tree, lhs, rhs, code)
-      case _              => throw new FatalError("Incorrect arity for primitive")
-    }
-  }
-
-  /** Gen JS code for a simple unary operation. */
-  private def genSimpleUnaryOp(tree: Apply, arg: Tree, code: Int): js.Tree = {
-    import dotty.tools.backend.ScalaPrimitivesOps._
-
-    implicit val pos = tree.span
-
-    val resultIRType = toIRType(tree.tpe)
-    val genArg = adaptPrimitive(genExpr(arg), resultIRType)
-
-    (code: @switch) match {
-      case POS =>
-        genArg
-
-      case NEG =>
-        (resultIRType: @unchecked) match {
-          case jstpe.IntType =>
-            js.BinaryOp(js.BinaryOp.Int_-, js.IntLiteral(0), genArg)
-          case jstpe.LongType =>
-            js.BinaryOp(js.BinaryOp.Long_-, js.LongLiteral(0), genArg)
-          case jstpe.FloatType =>
-            js.BinaryOp(js.BinaryOp.Float_*, js.FloatLiteral(-1.0f), genArg)
-          case jstpe.DoubleType =>
-            js.BinaryOp(js.BinaryOp.Double_*, js.DoubleLiteral(-1.0), genArg)
-        }
-
-      case NOT =>
-        (resultIRType: @unchecked) match {
-          case jstpe.IntType =>
-            js.BinaryOp(js.BinaryOp.Int_^, js.IntLiteral(-1), genArg)
-          case jstpe.LongType =>
-            js.BinaryOp(js.BinaryOp.Long_^, js.LongLiteral(-1), genArg)
-        }
-
-      case ZNOT =>
-        js.UnaryOp(js.UnaryOp.Boolean_!, genArg)
-
-      case _ =>
-        throw new FatalError("Unknown unary operation code: " + code)
-    }
-  }
-
-  /** Gen JS code for a simple binary operation. */
-  private def genSimpleBinaryOp(tree: Apply, lhs: Tree, rhs: Tree, code: Int): js.Tree = {
-    import dotty.tools.backend.ScalaPrimitivesOps._
-
-    implicit val pos: SourcePosition = tree.sourcePos
-
-    val lhsIRType = toIRType(lhs.tpe)
-    val rhsIRType = toIRType(rhs.tpe)
-
-    val isShift = isShiftOp(code)
-
-    val opType = {
-      if (isShift) {
-        if (lhsIRType == jstpe.LongType) jstpe.LongType
-        else jstpe.IntType
-      } else {
-        (lhsIRType, rhsIRType) match {
-          case (jstpe.DoubleType, _) | (_, jstpe.DoubleType)                          => jstpe.DoubleType
-          case (jstpe.FloatType, _) | (_, jstpe.FloatType)                            => jstpe.FloatType
-          case (jstpe.LongType, _) | (_, jstpe.LongType)                              => jstpe.LongType
-          case (jstpe.IntType | jstpe.ByteType | jstpe.ShortType | jstpe.CharType, _) => jstpe.IntType
-          case (_, jstpe.IntType | jstpe.ByteType | jstpe.ShortType | jstpe.CharType) => jstpe.IntType
-          case (jstpe.BooleanType, _) | (_, jstpe.BooleanType)                        => jstpe.BooleanType
-          case _                                                                      => jstpe.AnyType
-        }
-      }
-    }
-
-    val lsrc =
-      if (opType == jstpe.AnyType) genExpr(lhs)
-      else adaptPrimitive(genExpr(lhs), opType)
-    val rsrc =
-      if (opType == jstpe.AnyType) genExpr(rhs)
-      else adaptPrimitive(genExpr(rhs), if (isShift) jstpe.IntType else opType)
-
-    if (opType == jstpe.AnyType && isUniversalEqualityOp(code)) {
-      genUniversalEqualityOp(lhs.tpe, rhs.tpe, lsrc, rsrc, code)
-    } else if (code == ZOR) {
-      js.If(lsrc, js.BooleanLiteral(true), rsrc)(jstpe.BooleanType)
-    } else if (code == ZAND) {
-      js.If(lsrc, rsrc, js.BooleanLiteral(false))(jstpe.BooleanType)
-    } else {
-      import js.BinaryOp._
-
-      (opType: @unchecked) match {
-        case jstpe.IntType =>
-          val op = (code: @switch) match {
-            case ADD => Int_+
-            case SUB => Int_-
-            case MUL => Int_*
-            case DIV => Int_/
-            case MOD => Int_%
-            case OR  => Int_|
-            case AND => Int_&
-            case XOR => Int_^
-            case LSL => Int_<<
-            case LSR => Int_>>>
-            case ASR => Int_>>
-
-            case EQ => Int_==
-            case NE => Int_!=
-            case LT => Int_<
-            case LE => Int_<=
-            case GT => Int_>
-            case GE => Int_>=
-          }
-          js.BinaryOp(op, lsrc, rsrc)
-
-        case jstpe.FloatType =>
-          def withFloats(op: Int): js.Tree =
-            js.BinaryOp(op, lsrc, rsrc)
-
-          def toDouble(value: js.Tree): js.Tree =
-            js.UnaryOp(js.UnaryOp.FloatToDouble, value)
-
-          def withDoubles(op: Int): js.Tree =
-            js.BinaryOp(op, toDouble(lsrc), toDouble(rsrc))
-
-          (code: @switch) match {
-            case ADD => withFloats(Float_+)
-            case SUB => withFloats(Float_-)
-            case MUL => withFloats(Float_*)
-            case DIV => withFloats(Float_/)
-            case MOD => withFloats(Float_%)
-
-            case EQ => withDoubles(Double_==)
-            case NE => withDoubles(Double_!=)
-            case LT => withDoubles(Double_<)
-            case LE => withDoubles(Double_<=)
-            case GT => withDoubles(Double_>)
-            case GE => withDoubles(Double_>=)
-          }
-
-        case jstpe.DoubleType =>
-          val op = (code: @switch) match {
-            case ADD => Double_+
-            case SUB => Double_-
-            case MUL => Double_*
-            case DIV => Double_/
-            case MOD => Double_%
-
-            case EQ => Double_==
-            case NE => Double_!=
-            case LT => Double_<
-            case LE => Double_<=
-            case GT => Double_>
-            case GE => Double_>=
-          }
-          js.BinaryOp(op, lsrc, rsrc)
-
-        case jstpe.LongType =>
-          val op = (code: @switch) match {
-            case ADD => Long_+
-            case SUB => Long_-
-            case MUL => Long_*
-            case DIV => Long_/
-            case MOD => Long_%
-            case OR  => Long_|
-            case XOR => Long_^
-            case AND => Long_&
-            case LSL => Long_<<
-            case LSR => Long_>>>
-            case ASR => Long_>>
-
-            case EQ => Long_==
-            case NE => Long_!=
-            case LT => Long_<
-            case LE => Long_<=
-            case GT => Long_>
-            case GE => Long_>=
-          }
-          js.BinaryOp(op, lsrc, rsrc)
-
-        case jstpe.BooleanType =>
-          val op = (code: @switch) match {
-            case EQ  => Boolean_==
-            case NE  => Boolean_!=
-            case OR  => Boolean_|
-            case AND => Boolean_&
-            case XOR => Boolean_!=
-          }
-          js.BinaryOp(op, lsrc, rsrc)
-
-        case jstpe.AnyType =>
-          val op = code match {
-            case ID => ===
-            case NI => !==
-          }
-          js.BinaryOp(op, lsrc, rsrc)
-      }
-    }
-  }
-
-  private def adaptPrimitive(value: js.Tree, to: jstpe.Type)(
-      implicit pos: Position): js.Tree = {
-    genConversion(value.tpe, to, value)
-  }
-
-  /* This method corresponds to the method of the same name in
-   * BCodeBodyBuilder of the JVM back-end. It ends up calling the method
-   * BCodeIdiomatic.emitT2T, whose logic we replicate here.
-    */
-  private def genConversion(from: jstpe.Type, to: jstpe.Type, value: js.Tree)(
-      implicit pos: Position): js.Tree = {
-    import js.UnaryOp._
-
-    if (from == to || from == jstpe.NothingType) {
-      value
-    } else if (from == jstpe.BooleanType || to == jstpe.BooleanType) {
-      throw new AssertionError(s"Invalid genConversion from $from to $to")
-    } else {
-      def intValue = (from: @unchecked) match {
-        case jstpe.IntType    => value
-        case jstpe.CharType   => js.UnaryOp(CharToInt, value)
-        case jstpe.ByteType   => js.UnaryOp(ByteToInt, value)
-        case jstpe.ShortType  => js.UnaryOp(ShortToInt, value)
-        case jstpe.LongType   => js.UnaryOp(LongToInt, value)
-        case jstpe.FloatType  => js.UnaryOp(DoubleToInt, js.UnaryOp(FloatToDouble, value))
-        case jstpe.DoubleType => js.UnaryOp(DoubleToInt, value)
-      }
-
-      def doubleValue = from match {
-        case jstpe.DoubleType => value
-        case jstpe.FloatType  => js.UnaryOp(FloatToDouble, value)
-        case jstpe.LongType   => js.UnaryOp(LongToDouble, value)
-        case _                => js.UnaryOp(IntToDouble, intValue)
-      }
-
-      (to: @unchecked) match {
-        case jstpe.CharType =>
-          js.UnaryOp(IntToChar, intValue)
-        case jstpe.ByteType =>
-          js.UnaryOp(IntToByte, intValue)
-        case jstpe.ShortType =>
-          js.UnaryOp(IntToShort, intValue)
-        case jstpe.IntType =>
-          intValue
-        case jstpe.LongType =>
-          from match {
-            case jstpe.FloatType | jstpe.DoubleType =>
-              js.UnaryOp(DoubleToLong, doubleValue)
-            case _ =>
-              js.UnaryOp(IntToLong, intValue)
-          }
-        case jstpe.FloatType =>
-          if (from == jstpe.LongType)
-            js.UnaryOp(js.UnaryOp.LongToFloat, value)
-          else
-            js.UnaryOp(js.UnaryOp.DoubleToFloat, doubleValue)
-        case jstpe.DoubleType =>
-          doubleValue
-      }
-    }
-  }
-
-  /** Gen JS code for a universal equality test. */
-  private def genUniversalEqualityOp(ltpe: Type, rtpe: Type, lhs: js.Tree, rhs: js.Tree, code: Int)(
-      implicit pos: SourcePosition): js.Tree = {
-
-    import dotty.tools.backend.ScalaPrimitivesOps._
-
-    val bypassEqEq = {
-      // Do not call equals if we have a literal null at either side.
-      lhs.isInstanceOf[js.Null] ||
-      rhs.isInstanceOf[js.Null]
-    }
-
-    if (bypassEqEq) {
-      js.BinaryOp(
-          if (code == EQ) js.BinaryOp.=== else js.BinaryOp.!==,
-          lhs, rhs)
-    } else {
-      val body = genEqEqPrimitive(ltpe, rtpe, lhs, rhs)
-      if (code == EQ) body
-      else js.UnaryOp(js.UnaryOp.Boolean_!, body)
-    }
-  }
-
-  private lazy val externalEqualsNumNum: Symbol =
-    defn.BoxesRunTimeModule.requiredMethod(nme.equalsNumNum)
-  private lazy val externalEqualsNumChar: Symbol =
-    defn.BoxesRunTimeModule.requiredMethod(nme.equalsNumChar)
-  private lazy val externalEqualsNumObject: Symbol =
-    defn.BoxesRunTimeModule.requiredMethod(nme.equalsNumObject)
-  private lazy val externalEquals: Symbol =
-    defn.BoxesRunTimeModule.info.decl(nme.equals_).suchThat(toDenot(_).info.firstParamTypes.size == 2).symbol
-
-  /** Gen JS code for a call to Any.== */
-  private def genEqEqPrimitive(ltpe: Type, rtpe: Type, lsrc: js.Tree, rsrc: js.Tree)(
-      implicit pos: SourcePosition): js.Tree = {
-    report.debuglog(s"$ltpe == $rtpe")
-    val lsym = ltpe.typeSymbol.asClass
-    val rsym = rtpe.typeSymbol.asClass
-
-    /* True if the equality comparison is between values that require the
-     * use of the rich equality comparator
-     * (scala.runtime.BoxesRunTime.equals).
-     * This is the case when either side of the comparison might have a
-     * run-time type subtype of java.lang.Number or java.lang.Character,
-     * **which includes when either is a JS type**.
-     * When it is statically known that both sides are equal and subtypes of
-     * Number or Character, not using the rich equality is possible (their
-     * own equals method will do ok), except for java.lang.Float and
-     * java.lang.Double: their `equals` have different behavior around `NaN`
-     * and `-0.0`, see Javadoc (scala-dev#329, scala-js#2799).
-     */
-    val mustUseAnyComparator: Boolean = {
-      lsym.isJSType || rsym.isJSType || {
-        val p = ctx.platform
-        p.isMaybeBoxed(lsym) && p.isMaybeBoxed(rsym) && {
-          val areSameFinals = lsym.is(Final) && rsym.is(Final) && (ltpe =:= rtpe)
-          !areSameFinals || lsym == defn.BoxedFloatClass || lsym == defn.BoxedDoubleClass
-        }
-      }
-    }
-
-    if (mustUseAnyComparator) {
-      val equalsMethod: Symbol = {
-        val ptfm = ctx.platform
-        if (lsym.derivesFrom(defn.BoxedNumberClass)) {
-          if (rsym.derivesFrom(defn.BoxedNumberClass)) externalEqualsNumNum
-          else if (rsym.derivesFrom(defn.BoxedCharClass)) externalEqualsNumChar
-          else externalEqualsNumObject
-        } else externalEquals
-      }
-      genApplyStatic(equalsMethod, List(lsrc, rsrc))
-    } else {
-      // if (lsrc eq null) rsrc eq null else lsrc.equals(rsrc)
-      if (lsym == defn.StringClass) {
-        // String.equals(that) === (this eq that)
-        js.BinaryOp(js.BinaryOp.===, lsrc, rsrc)
-      } else {
-        /* This requires to evaluate both operands in local values first.
-         * The optimizer will eliminate them if possible.
-         */
-        val ltemp = js.VarDef(freshLocalIdent(), NoOriginalName, lsrc.tpe, mutable = false, lsrc)
-        val rtemp = js.VarDef(freshLocalIdent(), NoOriginalName, rsrc.tpe, mutable = false, rsrc)
-        js.Block(
-            ltemp,
-            rtemp,
-            js.If(js.BinaryOp(js.BinaryOp.===, ltemp.ref, js.Null()),
-                js.BinaryOp(js.BinaryOp.===, rtemp.ref, js.Null()),
-                genApplyMethod(ltemp.ref, defn.Any_equals, List(rtemp.ref)))(
-                jstpe.BooleanType))
-      }
-    }
-  }
-
-  /** Gen JS code for string concatenation.
-   */
-  private def genStringConcat(tree: Apply, receiver: Tree,
-      args: List[Tree]): js.Tree = {
-    implicit val pos = tree.span
-
-    js.BinaryOp(js.BinaryOp.String_+, genExpr(receiver), genExpr(args.head))
-  }
-
-  /** Gen JS code for a call to Any.## */
-  private def genScalaHash(tree: Apply, receiver: Tree): js.Tree = {
-    implicit val pos: SourcePosition = tree.sourcePos
-
-    genModuleApplyMethod(defn.ScalaRuntimeModule.requiredMethod(nme.hash_),
-        List(genExpr(receiver)))
-  }
-
-  /** Gen JS code for an array operation (get, set or length) */
-  private def genArrayOp(tree: Tree, code: Int): js.Tree = {
-    import dotty.tools.backend.ScalaPrimitivesOps._
-
-    implicit val pos = tree.span
-
-    val Apply(fun, args) = tree: @unchecked
-    val arrayObj = qualifierOf(fun)
-
-    val genArray = genExpr(arrayObj)
-    val genArgs = args.map(genExpr)
-
-    def elementType: Type = arrayObj.tpe.widenDealias match {
-      case defn.ArrayOf(el)  => el
-      case JavaArrayType(el) => el
-      case tpe =>
-        val msg = em"expected Array $tpe"
-        report.error(msg)
-        ErrorType(msg)
-    }
-
-    def genSelect(): js.AssignLhs =
-      js.ArraySelect(genArray, genArgs(0))(toIRType(elementType))
-
-    if (isArrayGet(code)) {
-      // get an item of the array
-      assert(args.length == 1,
-          s"Array get requires 1 argument, found ${args.length} in $tree")
-      genSelect()
-    } else if (isArraySet(code)) {
-      // set an item of the array
-      assert(args.length == 2,
-          s"Array set requires 2 arguments, found ${args.length} in $tree")
-      js.Assign(genSelect(), genArgs(1))
-    } else {
-      // length of the array
-      js.ArrayLength(genArray)
-    }
-  }
-
-  /** Gen JS code for a call to AnyRef.synchronized */
-  private def genSynchronized(tree: Apply, isStat: Boolean): js.Tree = {
-    /* JavaScript is single-threaded, so we can drop the
-     * synchronization altogether.
-     */
-    val Apply(fun, List(arg)) = tree
-    val receiver = qualifierOf(fun)
-
-    val genReceiver = genExpr(receiver)
-    val genArg = genStatOrExpr(arg, isStat)
-
-    genReceiver match {
-      case js.This() =>
-        // common case for which there is no side-effect nor NPE
-        genArg
-      case _ =>
-        implicit val pos = tree.span
-        js.Block(
-            js.If(js.BinaryOp(js.BinaryOp.===, genReceiver, js.Null()),
-                js.Throw(js.New(NullPointerExceptionClass, js.MethodIdent(jsNames.NoArgConstructorName), Nil)),
-                js.Skip())(jstpe.NoType),
-            genArg)
-    }
-  }
-
-  /** Gen JS code for a coercion */
-  private def genCoercion(tree: Apply, receiver: Tree, code: Int): js.Tree = {
-    implicit val pos = tree.span
-
-    val source = genExpr(receiver)
-    val resultType = toIRType(tree.tpe)
-    adaptPrimitive(source, resultType)
-  }
-
-  /** Gen a call to the special `throw` method. */
-  private def genThrow(tree: Apply, args: List[Tree]): js.Tree = {
-    implicit val pos: SourcePosition = tree.sourcePos
-    val exception = args.head
-    val genException = genExpr(exception)
-    genException match {
-      case js.New(cls, _, _) if cls != JavaScriptExceptionClassName =>
-        // Common case where ex is neither null nor a js.JavaScriptException
-        js.Throw(genException)
-      case _ =>
-        js.Throw(js.UnwrapFromThrowable(genException))
-    }
-  }
-
-  /** Gen a "normal" apply (to a true method).
-   *
-   *  But even these are further refined into:
-   *  * Methods of java.lang.String, which are redirected to the
-   *    RuntimeString trait implementation.
-   *  * Calls to methods of raw JS types (Scala.js -> JS interop)
-   *  * Calls to methods in impl classes of Scala2 traits.
-   *  * Regular method call
-   */
-  private def genNormalApply(tree: Apply, isStat: Boolean): js.Tree = {
-    implicit val pos = tree.span
-
-    val fun = tree.fun match {
-      case fun: Ident => desugarIdent(fun).get
-      case fun: Select => fun
-    }
-    val receiver = fun.qualifier
-    val args = tree.args
-    val sym = fun.symbol
-
-    def isStringMethodFromObject: Boolean = sym.name match {
-      case nme.toString_ | nme.equals_ | nme.hashCode_ => true
-      case _                                           => false
-    }
-
-    if (isMethodStaticInIR(sym)) {
-      genApplyStatic(sym, genActualArgs(sym, args))
-    } else if (sym.owner.isJSType) {
-      if (!sym.owner.isNonNativeJSClass || sym.isJSExposed)
-        genApplyJSMethodGeneric(sym, genExprOrGlobalScope(receiver), genActualJSArgs(sym, args), isStat)(tree.sourcePos)
-      else
-        genApplyJSClassMethod(genExpr(receiver), sym, genActualArgs(sym, args))
-    } else if (sym.hasAnnotation(jsdefn.JSNativeAnnot)) {
-      genJSNativeMemberCall(tree)
-    } else {
-      genApplyMethodMaybeStatically(genExpr(receiver), sym, genActualArgs(sym, args))
-    }
-  }
-
-  /** Gen JS code for a call to a JS method (of a subclass of `js.Any`).
-   *
-   *  Basically it boils down to calling the method as a `JSBracketSelect`,
-   *  without name mangling. But other aspects come into play:
-   *
-   *  - Operator methods are translated to JS operators (not method calls)
-   *  - `apply` is translated as a function call, i.e., `o()` instead of `o.apply()`
-   *  - Scala varargs are turned into JS varargs (see `genPrimitiveJSArgs()`)
-   *  - Getters and parameterless methods are translated as `JSBracketSelect`
-   *  - Setters are translated to `Assign` to `JSBracketSelect`
-   */
-  private def genApplyJSMethodGeneric(sym: Symbol,
-      receiver: MaybeGlobalScope, args: List[js.TreeOrJSSpread], isStat: Boolean,
-      jsSuperClassValue: Option[js.Tree] = None)(
-      implicit pos: SourcePosition): js.Tree = {
-
-    def argsNoSpread: List[js.Tree] = {
-      assert(!args.exists(_.isInstanceOf[js.JSSpread]), s"Unexpected spread at $pos")
-      args.asInstanceOf[List[js.Tree]]
-    }
-
-    val argc = args.size // meaningful only for methods that don't have varargs
-
-    def requireNotSuper(): Unit = {
-      if (jsSuperClassValue.isDefined)
-        report.error("Illegal super call in Scala.js-defined JS class", pos)
-    }
-
-    def requireNotSpread(arg: js.TreeOrJSSpread): js.Tree =
-      arg.asInstanceOf[js.Tree]
-
-    def genSuperReference(propName: js.Tree): js.AssignLhs = {
-      jsSuperClassValue.fold[js.AssignLhs] {
-        genJSSelectOrGlobalRef(receiver, propName)
-      } { superClassValue =>
-        js.JSSuperSelect(superClassValue, ruleOutGlobalScope(receiver), propName)
-      }
-    }
-
-    def genSelectGet(propName: js.Tree): js.Tree =
-      genSuperReference(propName)
-
-    def genSelectSet(propName: js.Tree, value: js.Tree): js.Tree =
-      js.Assign(genSuperReference(propName), value)
-
-    def genCall(methodName: js.Tree, args: List[js.TreeOrJSSpread]): js.Tree = {
-      jsSuperClassValue.fold[js.Tree] {
-        genJSMethodApplyOrGlobalRefApply(receiver, methodName, args)
-      } { superClassValue =>
-        js.JSSuperMethodCall(superClassValue, ruleOutGlobalScope(receiver), methodName, args)
-      }
-    }
-
-    val boxedResult = sym.jsCallingConvention match {
-      case JSCallingConvention.UnaryOp(code) =>
-        requireNotSuper()
-        assert(argc == 0, s"bad argument count ($argc) for unary op at $pos")
-        js.JSUnaryOp(code, ruleOutGlobalScope(receiver))
-
-      case JSCallingConvention.BinaryOp(code) =>
-        requireNotSuper()
-        assert(argc == 1, s"bad argument count ($argc) for binary op at $pos")
-        js.JSBinaryOp(code, ruleOutGlobalScope(receiver), requireNotSpread(args.head))
-
-      case JSCallingConvention.Call =>
-        requireNotSuper()
-        if (sym.owner.isSubClass(jsdefn.JSThisFunctionClass))
-          js.JSMethodApply(ruleOutGlobalScope(receiver), js.StringLiteral("call"), args)
-        else
-          js.JSFunctionApply(ruleOutGlobalScope(receiver), args)
-
-      case JSCallingConvention.Property(jsName) =>
-        argsNoSpread match {
-          case Nil =>
-            genSelectGet(genExpr(jsName))
-          case value :: Nil =>
-            genSelectSet(genExpr(jsName), value)
-          case _ =>
-            throw new AssertionError(s"property methods should have 0 or 1 non-varargs arguments at $pos")
-        }
-
-      case JSCallingConvention.BracketAccess =>
-        argsNoSpread match {
-          case keyArg :: Nil =>
-            genSelectGet(keyArg)
-          case keyArg :: valueArg :: Nil =>
-            genSelectSet(keyArg, valueArg)
-          case _ =>
-            throw new AssertionError(s"@JSBracketAccess methods should have 1 or 2 non-varargs arguments at $pos")
-        }
-
-      case JSCallingConvention.BracketCall =>
-        val (methodName, actualArgs) = extractFirstArg(args)
-        genCall(methodName, actualArgs)
-
-      case JSCallingConvention.Method(jsName) =>
-        genCall(genExpr(jsName), args)
-    }
-
-    if (isStat) {
-      boxedResult
-    } else {
-      val tpe = atPhase(elimErasedValueTypePhase) {
-        sym.info.finalResultType
-      }
-      if (tpe.isRef(defn.BoxedUnitClass) && sym.isGetter) {
-        /* Work around to reclaim Scala 2 erasure behavior, assumed by the test
-         * NonNativeJSTypeTest.defaultValuesForFields.
-         * Scala 2 erases getters of `Unit`-typed fields as returning `Unit`
-         * (not `BoxedUnit`). Therefore, when called in expression position,
-         * the call site introduces an explicit `BoxedUnit.UNIT`. Even if the
-         * field has not been initialized at all (with `= _`), this results in
-         * an actual `()` value.
-         * In Scala 3, the same pattern returns `null`, as a `BoxedUnit`, so we
-         * introduce here an explicit `()` value.
-         * TODO We should remove this branch if the upstream test is updated
-         * not to assume such a strict interpretation of erasure.
-         */
-        js.Block(boxedResult, js.Undefined())
-      } else {
-        unbox(boxedResult, tpe)
-      }
-    }
-  }
-
-  /** Extract the first argument in a list of actual arguments.
-   *
-   *  This is nothing else than decomposing into head and tail, except that
-   *  we assert that the first element is not a JSSpread.
-   */
-  private def extractFirstArg(args: List[js.TreeOrJSSpread]): (js.Tree, List[js.TreeOrJSSpread]) = {
-    assert(args.nonEmpty,
-        "Trying to extract the first argument of an empty argument list")
-    val firstArg = args.head
-    assert(!firstArg.isInstanceOf[js.JSSpread],
-        "Trying to extract the first argument of an argument list starting " +
-        "with a Spread argument: " + firstArg)
-    (firstArg.asInstanceOf[js.Tree], args.tail)
-  }
-
-  /** Gen JS code for a call to a native JS def or val. */
-  private def genJSNativeMemberSelect(tree: Tree): js.Tree =
-    genJSNativeMemberSelectOrCall(tree, Nil)
-
-  /** Gen JS code for a call to a native JS def or val. */
-  private def genJSNativeMemberCall(tree: Apply): js.Tree =
-    genJSNativeMemberSelectOrCall(tree, tree.args)
-
-  /** Gen JS code for a call to a native JS def or val. */
-  private def genJSNativeMemberSelectOrCall(tree: Tree, args: List[Tree]): js.Tree = {
-    val sym = tree.symbol
-
-    implicit val pos = tree.span
-
-    val jsNativeMemberValue =
-      js.SelectJSNativeMember(encodeClassName(sym.owner), encodeJSNativeMemberSym(sym))
-
-    val boxedResult =
-      if (sym.isJSGetter) jsNativeMemberValue
-      else js.JSFunctionApply(jsNativeMemberValue, genActualJSArgs(sym, args))
-
-    unbox(boxedResult, atPhase(elimErasedValueTypePhase) {
-      sym.info.resultType
-    })
-  }
-
-  private def genJSSuperCall(tree: Apply, isStat: Boolean): js.Tree = {
-    acquireContextualJSClassValue { explicitJSSuperClassValue =>
-      implicit val pos = tree.span
-      val Apply(fun @ Select(sup @ Super(qual, _), _), args) = tree: @unchecked
-      val sym = fun.symbol
-
-      val genReceiver = genExpr(qual)
-      def genScalaArgs = genActualArgs(sym, args)
-      def genJSArgs = genActualJSArgs(sym, args)
-
-      if (sym.owner == defn.ObjectClass) {
-        // Normal call anyway
-        assert(!sym.isClassConstructor,
-            s"Trying to call the super constructor of Object in a non-native JS class at $pos")
-        genApplyMethod(genReceiver, sym, genScalaArgs)
-      } else if (sym.isClassConstructor) {
-        throw new AssertionError(
-            s"calling a JS super constructor should have happened in genPrimaryJSClassCtor at $pos")
-      } else if (sym.owner.isNonNativeJSClass && !sym.isJSExposed) {
-        // Reroute to the static method
-        genApplyJSClassMethod(genReceiver, sym, genScalaArgs)
-      } else {
-        val jsSuperClassValue = explicitJSSuperClassValue.orElse {
-          Some(genLoadJSConstructor(currentClassSym.get.asClass.superClass))
-        }
-        genApplyJSMethodGeneric(sym, MaybeGlobalScope.NotGlobalScope(genReceiver),
-            genJSArgs, isStat, jsSuperClassValue)(tree.sourcePos)
-      }
-    }
-  }
-
-  /** Gen JS code for a call to a polymorphic method.
-   *
-   *  The only methods that reach the back-end as polymorphic are
-   *  `isInstanceOf` and `asInstanceOf`.
-   *
-   *  (Well, in fact `DottyRunTime.newRefArray` too, but it is handled as a
-   *  primitive instead.)
-   */
-  private def genTypeApply(tree: TypeApply): js.Tree = {
-    implicit val pos: SourcePosition = tree.sourcePos
-
-    val TypeApply(fun, targs) = tree
-
-    val sym = fun.symbol
-    val receiver = qualifierOf(fun)
-
-    val to = targs.head.tpe
-
-    assert(!isPrimitiveValueType(receiver.tpe),
-        s"Found receiver of type test with primitive type ${receiver.tpe} at $pos")
-    assert(!isPrimitiveValueType(to),
-        s"Found target type of type test with primitive type ${receiver.tpe} at $pos")
-
-    val genReceiver = genExpr(receiver)
-
-    if (sym == defn.Any_asInstanceOf) {
-      genAsInstanceOf(genReceiver, to)
-    } else if (sym == defn.Any_isInstanceOf) {
-      genIsInstanceOf(genReceiver, to)
-    } else {
-      throw new FatalError(
-          s"Unexpected type application $fun with symbol ${sym.fullName}")
-    }
-  }
-
-  /** Gen JS code for a Java Seq literal. */
-  private def genJavaSeqLiteral(tree: JavaSeqLiteral): js.Tree = {
-    implicit val pos = tree.span
-
-    val genElems = tree.elems.map(genExpr)
-    val arrayTypeRef = toTypeRef(tree.tpe).asInstanceOf[jstpe.ArrayTypeRef]
-    js.ArrayValue(arrayTypeRef, genElems)
-  }
-
-  /** Gen JS code for a switch-`Match`, which is translated into an IR `js.Match`. */
-  def genMatch(tree: Tree, isStat: Boolean): js.Tree = {
-    implicit val pos = tree.span
-    val Match(selector, cases) = tree: @unchecked
-
-    def abortMatch(msg: String): Nothing =
-      throw new FatalError(s"$msg in switch-like pattern match at ${tree.span}: $tree")
-
-    val genSelector = genExpr(selector)
-
-    // Sanity check: we can handle Ints and Strings (including `null`s), but nothing else
-    genSelector.tpe match {
-      case jstpe.IntType | jstpe.ClassType(jsNames.BoxedStringClass) | jstpe.NullType | jstpe.NothingType =>
-        // ok
-      case _ =>
-        abortMatch(s"Invalid selector type ${genSelector.tpe}")
-    }
-
-    val resultType = toIRType(tree.tpe) match {
-      case jstpe.NothingType => jstpe.NothingType // must take priority over NoType below
-      case _ if isStat       => jstpe.NoType
-      case resType           => resType
-    }
-
-    var clauses: List[(List[js.MatchableLiteral], js.Tree)] = Nil
-    var optDefaultClause: Option[js.Tree] = None
-
-    for (caze @ CaseDef(pat, guard, body) <- cases) {
-      if (guard != EmptyTree)
-        abortMatch("Found a case guard")
-
-      val genBody = genStatOrExpr(body, isStat)
-
-      def invalidCase(): Nothing =
-        abortMatch("Invalid case")
-
-      def genMatchableLiteral(tree: Literal): js.MatchableLiteral = {
-        genExpr(tree) match {
-          case matchableLiteral: js.MatchableLiteral => matchableLiteral
-          case otherExpr                             => invalidCase()
-        }
-      }
-
-      pat match {
-        case lit: Literal =>
-          clauses = (List(genMatchableLiteral(lit)), genBody) :: clauses
-        case Ident(nme.WILDCARD) =>
-          optDefaultClause = Some(genBody)
-        case Alternative(alts) =>
-          val genAlts = alts.map {
-            case lit: Literal => genMatchableLiteral(lit)
-            case _            => invalidCase()
-          }
-          clauses = (genAlts, genBody) :: clauses
-        case _ =>
-          invalidCase()
-      }
-    }
-
-    clauses = clauses.reverse
-    val defaultClause = optDefaultClause.getOrElse {
-      throw new AssertionError("No elseClause in pattern match")
-    }
-
-    /* Builds a `js.Match`, but simplifies it to a `js.If` if there is only
-     * one case with one alternative, and to a `js.Block` if there is no case
-     * at all. This happens in practice in the standard library. Having no
-     * case is a typical product of `match`es that are full of
-     * `case n if ... =>`, which are used instead of `if` chains for
-     * convenience and/or readability.
-     */
-    def isInt(tree: js.Tree): Boolean = tree.tpe == jstpe.IntType
-
-    clauses match {
-      case Nil =>
-        // Completely remove the Match. Preserve the side-effects of `genSelector`.
-        js.Block(exprToStat(genSelector), defaultClause)
-
-      case (uniqueAlt :: Nil, caseRhs) :: Nil =>
-        /* Simplify the `match` as an `if`, so that the optimizer has less
-         * work to do, and we emit less code at the end of the day.
-         * Use `Int_==` instead of `===` if possible, since it is a common case.
-         */
-        val op =
-          if (isInt(genSelector) && isInt(uniqueAlt)) js.BinaryOp.Int_==
-          else js.BinaryOp.===
-        js.If(js.BinaryOp(op, genSelector, uniqueAlt), caseRhs, defaultClause)(resultType)
-
-      case _ =>
-        // We have more than one case: use a js.Match
-        js.Match(genSelector, clauses, defaultClause)(resultType)
-    }
-  }
-
-  /** Gen JS code for a closure.
-   *
-   *  Input: a `Closure` tree of the form
-   *  {{{
-   *  Closure(env, call, functionalInterface)
-   *  }}}
-   *  representing the pseudo-syntax
-   *  {{{
-   *  { (p1, ..., pm) => call(env1, ..., envn, p1, ..., pm) }: functionInterface
-   *  }}}
-   *  where `envi` are identifiers in the local scope. The qualifier of `call`
-   *  is also implicitly captured.
-   *
-   *  Output: a `js.Closure` tree of the form
-   *  {{{
-   *  js.Closure(formalCaptures, formalParams, body, actualCaptures)
-   *  }}}
-   *  representing the pseudo-syntax
-   *  {{{
-   *  lambda<formalCapture1 = actualCapture1, ..., formalCaptureN = actualCaptureN>(
-   *      formalParam1, ..., formalParamM) = body
-   *  }}}
-   *  where the `actualCaptures` and `body` are, in general, arbitrary
-   *  expressions. But in this case, `actualCaptures` will be identifiers from
-   *  `env`, and the `body` will be of the form
-   *  {{{
-   *  call(formalCapture1.ref, ..., formalCaptureN.ref,
-   *      formalParam1.ref, ...formalParamM.ref)
-   *  }}}
-   *
-   *  When the `js.Closure` node is evaluated, i.e., when the closure value is
-   *  created, the expressions of the `actualCaptures` are evaluated, and the
-   *  results of those evaluations is "stored" in the environment of the
-   *  closure as the corresponding `formalCapture`.
-   *
-   *  When we later *call* the closure, the `formalCaptures` already have their
-   *  values from the environment, and they are available in the `body`. The
-   *  `formalParams` of the created closure receive their values from the
-   *  actual arguments at the call-site of the closure, and they are also
-   *  available in the `body`.
-   */
-  private def genClosure(tree: Closure): js.Tree = {
-    implicit val pos = tree.span
-    val Closure(env, call, functionalInterface) = tree
-
-    val envSize = env.size
-
-    val (fun, args) = call match {
-      // case Apply(fun, args) => (fun, args) // Conjectured not to happen
-      case t @ Select(_, _) => (t, Nil)
-      case t @ Ident(_) => (t, Nil)
-    }
-    val sym = fun.symbol
-    val isStaticCall = isMethodStaticInIR(sym)
-
-    val qualifier = qualifierOf(fun)
-    val allCaptureValues =
-      if (isStaticCall) env
-      else qualifier :: env
-
-    val formalAndActualCaptures = allCaptureValues.map { value =>
-      implicit val pos = value.span
-      val (formalIdent, originalName) = value match {
-        case Ident(name) => (freshLocalIdent(name.toTermName), OriginalName(name.toString))
-        case This(_)     => (freshLocalIdent("this"), thisOriginalName)
-        case _           => (freshLocalIdent(), NoOriginalName)
-      }
-      val formalCapture = js.ParamDef(formalIdent, originalName,
-          toIRType(value.tpe), mutable = false)
-      val actualCapture = genExpr(value)
-      (formalCapture, actualCapture)
-    }
-    val (formalCaptures, actualCaptures) = formalAndActualCaptures.unzip
-
-    val funInterfaceSym = functionalInterface.tpe.typeSymbol
-    val hasRepeatedParam = {
-      funInterfaceSym.exists && {
-        val Seq(samMethodDenot) = funInterfaceSym.info.possibleSamMethods
-        val samMethod = samMethodDenot.symbol
-        atPhase(elimRepeatedPhase)(samMethod.info.paramInfoss.flatten.exists(_.isRepeatedParam))
-      }
-    }
-
-    val formalParamNames = sym.info.paramNamess.flatten.drop(envSize)
-    val formalParamTypes = sym.info.paramInfoss.flatten.drop(envSize)
-    val formalParamRepeateds =
-      if (hasRepeatedParam) (0 until (formalParamTypes.size - 1)).map(_ => false) :+ true
-      else (0 until formalParamTypes.size).map(_ => false)
-
-    val formalAndActualParams = formalParamNames.lazyZip(formalParamTypes).lazyZip(formalParamRepeateds).map {
-      (name, tpe, repeated) =>
-        val formalParam = js.ParamDef(freshLocalIdent(name),
-            OriginalName(name.toString), jstpe.AnyType, mutable = false)
-        val actualParam =
-          if (repeated) genJSArrayToVarArgs(formalParam.ref)(tree.sourcePos)
-          else unbox(formalParam.ref, tpe)
-        (formalParam, actualParam)
-    }
-    val (formalAndRestParams, actualParams) = formalAndActualParams.unzip
-
-    val (formalParams, restParam) =
-      if (hasRepeatedParam) (formalAndRestParams.init, Some(formalAndRestParams.last))
-      else (formalAndRestParams, None)
-
-    val genBody = {
-      val call = if (isStaticCall) {
-        genApplyStatic(sym, formalCaptures.map(_.ref) ::: actualParams)
-      } else {
-        val thisCaptureRef :: argCaptureRefs = formalCaptures.map(_.ref): @unchecked
-        if (!sym.owner.isNonNativeJSClass || sym.isJSExposed)
-          genApplyMethodMaybeStatically(thisCaptureRef, sym, argCaptureRefs ::: actualParams)
-        else
-          genApplyJSClassMethod(thisCaptureRef, sym, argCaptureRefs ::: actualParams)
-      }
-      box(call, sym.info.finalResultType)
-    }
-
-    val isThisFunction = funInterfaceSym.isSubClass(jsdefn.JSThisFunctionClass) && {
-      val ok = formalParams.nonEmpty
-      if (!ok)
-        report.error("The SAM or apply method for a js.ThisFunction must have a leading non-varargs parameter", tree)
-      ok
-    }
-
-    if (isThisFunction) {
-      val thisParam :: otherParams = formalParams: @unchecked
-      js.Closure(
-          arrow = false,
-          formalCaptures,
-          otherParams,
-          restParam,
-          js.Block(
-              js.VarDef(thisParam.name, thisParam.originalName,
-                  thisParam.ptpe, mutable = false,
-                  js.This()(thisParam.ptpe)(thisParam.pos))(thisParam.pos),
-              genBody),
-          actualCaptures)
-    } else {
-      val closure = js.Closure(arrow = true, formalCaptures, formalParams, restParam, genBody, actualCaptures)
-
-      if (!funInterfaceSym.exists || defn.isFunctionClass(funInterfaceSym)) {
-        assert(!funInterfaceSym.exists || defn.isFunctionClass(funInterfaceSym),
-            s"Invalid functional interface $funInterfaceSym reached the back-end")
-        val formalCount = formalParams.size
-        val cls = ClassName("scala.scalajs.runtime.AnonFunction" + formalCount)
-        val ctorName = MethodName.constructor(
-            jstpe.ClassRef(ClassName("scala.scalajs.js.Function" + formalCount)) :: Nil)
-        js.New(cls, js.MethodIdent(ctorName), List(closure))
-      } else {
-        assert(funInterfaceSym.isJSType,
-            s"Invalid functional interface $funInterfaceSym reached the back-end")
-        closure
-      }
-    }
-  }
-
-  /** Generates a static method instantiating and calling this
-   *  DynamicImportThunk's `apply`:
-   *
-   *  {{{
-   *  static def dynamicImport$;<params>;Ljava.lang.Object(<params>): any = {
-   *    new <clsSym>.<init>;<params>:V(<params>).apply;Ljava.lang.Object()
-   *  }
-   *  }}}
-   */
-  private def genDynamicImportForwarder(clsSym: Symbol)(using Position): js.MethodDef = {
-    withNewLocalNameScope {
-      val ctor = clsSym.primaryConstructor
-      val paramSyms = ctor.paramSymss.flatten
-      val paramDefs = paramSyms.map(genParamDef(_))
-
-      val body = {
-        val inst = js.New(encodeClassName(clsSym), encodeMethodSym(ctor), paramDefs.map(_.ref))
-        genApplyMethod(inst, jsdefn.DynamicImportThunkClass_apply, Nil)
-      }
-
-      js.MethodDef(
-          js.MemberFlags.empty.withNamespace(js.MemberNamespace.PublicStatic),
-          encodeDynamicImportForwarderIdent(paramSyms),
-          NoOriginalName,
-          paramDefs,
-          jstpe.AnyType,
-          Some(body))(OptimizerHints.empty, None)
-    }
-  }
-
-  /** Boxes a value of the given type before `elimErasedValueType`.
-   *
-   *  This should be used when sending values to a JavaScript context, which
-   *  is erased/boxed at the IR level, although it is not erased at the
-   *  dotty/JVM level.
-   *
-   *  @param expr Tree to be boxed if needed.
-   *  @param tpeEnteringElimErasedValueType The type of `expr` as it was
-   *    entering the `elimErasedValueType` phase.
-   */
-  def box(expr: js.Tree, tpeEnteringElimErasedValueType: Type)(implicit pos: Position): js.Tree = {
-    tpeEnteringElimErasedValueType match {
-      case tpe if isPrimitiveValueType(tpe) =>
-        makePrimitiveBox(expr, tpe)
-
-      case tpe: ErasedValueType =>
-        val boxedClass = tpe.tycon.typeSymbol
-        val ctor = boxedClass.primaryConstructor
-        js.New(encodeClassName(boxedClass), encodeMethodSym(ctor), List(expr))
-
-      case _ =>
-        expr
-    }
-  }
-
-  /** Unboxes a value typed as Any to the given type before `elimErasedValueType`.
-   *
-   *  This should be used when receiving values from a JavaScript context,
-   *  which is erased/boxed at the IR level, although it is not erased at the
-   *  dotty/JVM level.
-   *
-   *  @param expr Tree to be extracted.
-   *  @param tpeEnteringElimErasedValueType The type of `expr` as it was
-   *    entering the `elimErasedValueType` phase.
-   */
-  def unbox(expr: js.Tree, tpeEnteringElimErasedValueType: Type)(implicit pos: Position): js.Tree = {
-    tpeEnteringElimErasedValueType match {
-      case tpe if isPrimitiveValueType(tpe) =>
-        makePrimitiveUnbox(expr, tpe)
-
-      case tpe: ErasedValueType =>
-        val boxedClass = tpe.tycon.typeSymbol.asClass
-        val unboxMethod = ValueClasses.valueClassUnbox(boxedClass)
-        val content = genApplyMethod(
-            js.AsInstanceOf(expr, encodeClassType(boxedClass)), unboxMethod, Nil)
-        if (unboxMethod.info.resultType <:< tpe.erasedUnderlying)
-          content
-        else
-          unbox(content, tpe.erasedUnderlying)
-
-      case tpe =>
-        genAsInstanceOf(expr, tpe)
-    }
-  }
-
-  /** Gen JS code for an asInstanceOf cast (for reference types only) */
-  private def genAsInstanceOf(value: js.Tree, to: Type)(implicit pos: Position): js.Tree =
-    genAsInstanceOf(value, toIRType(to))
-
-  /** Gen JS code for an asInstanceOf cast (for reference types only) */
-  private def genAsInstanceOf(value: js.Tree, to: jstpe.Type)(implicit pos: Position): js.Tree = {
-    to match {
-      case jstpe.AnyType =>
-        value
-      case jstpe.NullType =>
-        js.If(
-            js.BinaryOp(js.BinaryOp.===, value, js.Null()),
-            js.Null(),
-            genThrowClassCastException())(
-            jstpe.NullType)
-      case jstpe.NothingType =>
-        js.Block(value, genThrowClassCastException())
-      case _ =>
-        js.AsInstanceOf(value, to)
-    }
-  }
-
-  private def genThrowClassCastException()(implicit pos: Position): js.Tree = {
-    js.Throw(js.New(jsNames.ClassCastExceptionClass,
-        js.MethodIdent(jsNames.NoArgConstructorName), Nil))
-  }
-
-  /** Gen JS code for an isInstanceOf test (for reference types only) */
-  def genIsInstanceOf(value: js.Tree, to: Type)(
-      implicit pos: SourcePosition): js.Tree = {
-    val sym = to.typeSymbol
-
-    if (sym == defn.ObjectClass) {
-      js.BinaryOp(js.BinaryOp.!==, value, js.Null())
-    } else if (sym.isJSType) {
-      if (sym.is(Trait)) {
-        report.error(
-            em"isInstanceOf[${sym.fullName}] not supported because it is a JS trait",
-            pos)
-        js.BooleanLiteral(true)
-      } else {
-        js.AsInstanceOf(js.JSBinaryOp(
-            js.JSBinaryOp.instanceof, value, genLoadJSConstructor(sym)),
-            jstpe.BooleanType)
-      }
-    } else {
-      // The Scala type system prevents x.isInstanceOf[Null] and ...[Nothing]
-      assert(sym != defn.NullClass && sym != defn.NothingClass,
-          s"Found a .isInstanceOf[$sym] at $pos")
-      js.IsInstanceOf(value, toIRType(to))
-    }
-  }
-
-  /** Gen a statically linked call to an instance method. */
-  def genApplyMethodMaybeStatically(receiver: js.Tree, method: Symbol,
-      arguments: List[js.Tree])(implicit pos: Position): js.Tree = {
-    if (method.isPrivate || method.isClassConstructor)
-      genApplyMethodStatically(receiver, method, arguments)
-    else
-      genApplyMethod(receiver, method, arguments)
-  }
-
-  /** Gen a dynamically linked call to a Scala method. */
-  def genApplyMethod(receiver: js.Tree, method: Symbol, arguments: List[js.Tree])(
-      implicit pos: Position): js.Tree = {
-    assert(!method.isPrivate,
-        s"Cannot generate a dynamic call to private method $method at $pos")
-    js.Apply(js.ApplyFlags.empty, receiver, encodeMethodSym(method), arguments)(
-        toIRType(patchedResultType(method)))
-  }
-
-  /** Gen a statically linked call to an instance method. */
-  def genApplyMethodStatically(receiver: js.Tree, method: Symbol, arguments: List[js.Tree])(
-      implicit pos: Position): js.Tree = {
-    val flags = js.ApplyFlags.empty
-      .withPrivate(method.isPrivate && !method.isClassConstructor)
-      .withConstructor(method.isClassConstructor)
-    js.ApplyStatically(flags, receiver, encodeClassName(method.owner),
-        encodeMethodSym(method), arguments)(
-        toIRType(patchedResultType(method)))
-  }
-
-  /** Gen a call to a static method. */
-  private def genApplyStatic(method: Symbol, arguments: List[js.Tree])(
-      implicit pos: Position): js.Tree = {
-    js.ApplyStatic(js.ApplyFlags.empty.withPrivate(method.isPrivate),
-        encodeClassName(method.owner), encodeMethodSym(method), arguments)(
-        toIRType(patchedResultType(method)))
-  }
-
-  /** Gen a call to a non-exposed method of a non-native JS class. */
-  def genApplyJSClassMethod(receiver: js.Tree, method: Symbol, arguments: List[js.Tree])(
-      implicit pos: Position): js.Tree = {
-    genApplyStatic(method, receiver :: arguments)
-  }
-
-  /** Gen a call to a method of a Scala top-level module. */
-  private def genModuleApplyMethod(methodSym: Symbol, arguments: List[js.Tree])(
-      implicit pos: SourcePosition): js.Tree = {
-    genApplyMethod(genLoadModule(methodSym.owner), methodSym, arguments)
-  }
-
-  /** Gen a boxing operation (tpe is the primitive type) */
-  private def makePrimitiveBox(expr: js.Tree, tpe: Type)(
-      implicit pos: Position): js.Tree = {
-    toIRType(tpe) match {
-      case jstpe.NoType => // for JS interop cases
-        js.Block(expr, js.Undefined())
-      case jstpe.BooleanType | jstpe.CharType | jstpe.ByteType |
-          jstpe.ShortType | jstpe.IntType | jstpe.LongType | jstpe.FloatType |
-          jstpe.DoubleType =>
-        expr // box is identity for all those primitive types
-      case typeRef =>
-        throw new FatalError(
-            s"makePrimitiveBox requires a primitive type, found $typeRef for $tpe at $pos")
-    }
-  }
-
-  /** Gen an unboxing operation (tpe is the primitive type) */
-  private def makePrimitiveUnbox(expr: js.Tree, tpe: Type)(
-      implicit pos: Position): js.Tree = {
-    toIRType(tpe) match {
-      case jstpe.NoType => expr // for JS interop cases
-      case irTpe        => js.AsInstanceOf(expr, irTpe)
-    }
-  }
-
-  /** Gen JS code for a Scala.js-specific primitive method */
-  private def genJSPrimitive(tree: Apply, args: List[Tree], code: Int,
-      isStat: Boolean): js.Tree = {
-
-    import JSPrimitives._
-
-    implicit val pos = tree.span
-
-    def genArgs1: js.Tree = {
-      assert(args.size == 1,
-          s"Expected exactly 1 argument for JS primitive $code but got " +
-          s"${args.size} at $pos")
-      genExpr(args.head)
-    }
-
-    def genArgs2: (js.Tree, js.Tree) = {
-      assert(args.size == 2,
-          s"Expected exactly 2 arguments for JS primitive $code but got " +
-          s"${args.size} at $pos")
-      (genExpr(args.head), genExpr(args.tail.head))
-    }
-
-    def genArgsVarLength: List[js.TreeOrJSSpread] =
-      genActualJSArgs(tree.symbol, args)
-
-    def resolveReifiedJSClassSym(arg: Tree): Symbol = {
-      def fail(): Symbol = {
-        report.error(
-            tree.symbol.name.toString + " must be called with a constant " +
-            "classOf[T] representing a class extending js.Any " +
-            "(not a trait nor an object)",
-            tree.sourcePos)
-        NoSymbol
-      }
-      arg match {
-        case Literal(value) if value.tag == Constants.ClazzTag =>
-          val classSym = value.typeValue.typeSymbol
-          if (classSym.isJSType && !classSym.is(Trait) && !classSym.is(ModuleClass))
-            classSym
-          else
-            fail()
-        case _ =>
-          fail()
-      }
-    }
-
-    (code: @switch) match {
-      case DYNNEW =>
-        // js.Dynamic.newInstance(clazz)(actualArgs: _*)
-        val (jsClass, actualArgs) = extractFirstArg(genArgsVarLength)
-        js.JSNew(jsClass, actualArgs)
-
-      case ARR_CREATE =>
-        // js.Array(elements: _*)
-        js.JSArrayConstr(genArgsVarLength)
-
-      case CONSTRUCTOROF =>
-        // runtime.constructorOf(clazz)
-        val classSym = resolveReifiedJSClassSym(args.head)
-        if (classSym == NoSymbol)
-          js.Undefined() // compile error emitted by resolveReifiedJSClassSym
-        else
-          genLoadJSConstructor(classSym)
-
-      case CREATE_INNER_JS_CLASS | CREATE_LOCAL_JS_CLASS =>
-        // runtime.createInnerJSClass(clazz, superClass)
-        // runtime.createLocalJSClass(clazz, superClass, fakeNewInstances)
-        val classSym = resolveReifiedJSClassSym(args(0))
-        val superClassValue = genExpr(args(1))
-        if (classSym == NoSymbol) {
-          js.Undefined() // compile error emitted by resolveReifiedJSClassSym
-        } else {
-          val captureValues = {
-            if (code == CREATE_INNER_JS_CLASS) {
-              /* Private inner classes that do not actually access their outer
-               * pointer do not receive an outer argument. We therefore count
-               * the number of constructors that have non-empty param list to
-               * know how many times we need to pass `this`.
-               */
-              val requiredThisParams =
-                classSym.info.decls.lookupAll(nme.CONSTRUCTOR).count(_.info.paramInfoss.head.nonEmpty)
-              val outer = genThis()
-              List.fill(requiredThisParams)(outer)
-            } else {
-              val fakeNewInstances = args(2).asInstanceOf[JavaSeqLiteral].elems
-              fakeNewInstances.flatMap(genCaptureValuesFromFakeNewInstance(_))
-            }
-          }
-          js.CreateJSClass(encodeClassName(classSym), superClassValue :: captureValues)
-        }
-
-      case WITH_CONTEXTUAL_JS_CLASS_VALUE =>
-        // withContextualJSClassValue(jsclass, inner)
-        val jsClassValue = genExpr(args(0))
-        withScopedVars(
-            contextualJSClassValue := Some(jsClassValue)
-        ) {
-          genStatOrExpr(args(1), isStat)
-        }
-
-      case LINKING_INFO =>
-        // runtime.linkingInfo
-        js.JSLinkingInfo()
-
-      case DEBUGGER =>
-        // js.special.debugger()
-        js.Debugger()
-
-      case UNITVAL =>
-        // BoxedUnit.UNIT, which is the boxed version of ()
-        js.Undefined()
-
-      case JS_NEW_TARGET =>
-        // js.new.target
-        val valid = currentMethodSym.get.isClassConstructor && currentClassSym.isNonNativeJSClass
-        if (!valid) {
-          report.error(
-              "Illegal use of js.`new`.target.\n" +
-              "It can only be used in the constructor of a JS class, " +
-              "as a statement or in the rhs of a val or var.\n" +
-              "It cannot be used inside a lambda or by-name parameter, nor in any other location.",
-              tree.sourcePos)
-        }
-        js.JSNewTarget()
-
-      case JS_IMPORT =>
-        // js.import(arg)
-        val arg = genArgs1
-        js.JSImportCall(arg)
-
-      case JS_IMPORT_META =>
-        // js.import.meta
-        js.JSImportMeta()
-
-      case DYNAMIC_IMPORT =>
-        // runtime.dynamicImport
-        assert(args.size == 1,
-            s"Expected exactly 1 argument for JS primitive $code but got " +
-            s"${args.size} at $pos")
-
-        args.head match {
-          case Block(stats, expr @ Typed(Apply(fun @ Select(New(tpt), _), args), _)) =>
-            /* stats is always empty if no other compiler plugin is present.
-             * However, code instrumentation (notably scoverage) might add
-             * statements here. If this is the case, the thunk anonymous class
-             * has already been created when the other plugin runs (i.e. the
-             * plugin ran after jsinterop).
-             *
-             * Therefore, it is OK to leave the statements on our side of the
-             * dynamic loading boundary.
-             */
-
-            val clsSym = tpt.symbol
-            val ctor = fun.symbol
-
-            assert(clsSym.isSubClass(jsdefn.DynamicImportThunkClass),
-                s"expected subclass of DynamicImportThunk, got: $clsSym at: ${expr.sourcePos}")
-            assert(ctor.isPrimaryConstructor,
-                s"expected primary constructor, got: $ctor at: ${expr.sourcePos}")
-
-            js.Block(
-                stats.map(genStat(_)),
-                js.ApplyDynamicImport(
-                    js.ApplyFlags.empty,
-                    encodeClassName(clsSym),
-                    encodeDynamicImportForwarderIdent(ctor.paramSymss.flatten),
-                    genActualArgs(ctor, args))
-            )
-
-          case tree =>
-            throw new FatalError(
-                s"Unexpected argument tree in dynamicImport: $tree/${tree.getClass} at: $pos")
-        }
-
-      case JS_NATIVE =>
-        // js.native
-        report.error(
-            "js.native may only be used as stub implementation in facade types",
-            tree.sourcePos)
-        js.Undefined()
-
-      case TYPEOF =>
-        // js.typeOf(arg)
-        val arg = genArgs1
-        val typeofExpr = arg match {
-          case arg: js.JSGlobalRef => js.JSTypeOfGlobalRef(arg)
-          case _                   => js.JSUnaryOp(js.JSUnaryOp.typeof, arg)
-        }
-        js.AsInstanceOf(typeofExpr, jstpe.ClassType(jsNames.BoxedStringClass))
-
-      case STRICT_EQ =>
-        // js.special.strictEquals(arg1, arg2)
-        val (arg1, arg2) = genArgs2
-        js.JSBinaryOp(js.JSBinaryOp.===, arg1, arg2)
-
-      case IN =>
-        // js.special.in(arg1, arg2)
-        val (arg1, arg2) = genArgs2
-        js.AsInstanceOf(js.JSBinaryOp(js.JSBinaryOp.in, arg1, arg2),
-            jstpe.BooleanType)
-
-      case INSTANCEOF =>
-        // js.special.instanceof(arg1, arg2)
-        val (arg1, arg2) = genArgs2
-        js.AsInstanceOf(js.JSBinaryOp(js.JSBinaryOp.instanceof, arg1, arg2),
-            jstpe.BooleanType)
-
-      case DELETE =>
-        // js.special.delete(arg1, arg2)
-        val (arg1, arg2) = genArgs2
-        js.JSDelete(arg1, arg2)
-
-      case FORIN =>
-        /* js.special.forin(arg1, arg2)
-         *
-         * We must generate:
-         *
-         * val obj = arg1
-         * val f = arg2
-         * for (val key in obj) {
-         *   f(key)
-         * }
-         *
-         * with temporary vals, because `arg2` must be evaluated only
-         * once, and after `arg1`.
-         */
-        val (arg1, arg2) = genArgs2
-        val objVarDef = js.VarDef(freshLocalIdent("obj"), NoOriginalName,
-            jstpe.AnyType, mutable = false, arg1)
-        val fVarDef = js.VarDef(freshLocalIdent("f"), NoOriginalName,
-            jstpe.AnyType, mutable = false, arg2)
-        val keyVarIdent = freshLocalIdent("key")
-        val keyVarRef = js.VarRef(keyVarIdent)(jstpe.AnyType)
-        js.Block(
-            objVarDef,
-            fVarDef,
-            js.ForIn(objVarDef.ref, keyVarIdent, NoOriginalName, {
-              js.JSFunctionApply(fVarDef.ref, List(keyVarRef))
-            }))
-
-      case JS_THROW =>
-        // js.special.throw(arg)
-        js.Throw(genArgs1)
-
-      case JS_TRY_CATCH =>
-        /* js.special.tryCatch(arg1, arg2)
-         *
-         * We must generate:
-         *
-         * val body = arg1
-         * val handler = arg2
-         * try {
-         *   body()
-         * } catch (e) {
-         *   handler(e)
-         * }
-         *
-         * with temporary vals, because `arg2` must be evaluated before
-         * `body` executes. Moreover, exceptions thrown while evaluating
-         * the function values `arg1` and `arg2` must not be caught.
-         */
-        val (arg1, arg2) = genArgs2
-        val bodyVarDef = js.VarDef(freshLocalIdent("body"), NoOriginalName,
-            jstpe.AnyType, mutable = false, arg1)
-        val handlerVarDef = js.VarDef(freshLocalIdent("handler"), NoOriginalName,
-            jstpe.AnyType, mutable = false, arg2)
-        val exceptionVarIdent = freshLocalIdent("e")
-        val exceptionVarRef = js.VarRef(exceptionVarIdent)(jstpe.AnyType)
-        js.Block(
-          bodyVarDef,
-          handlerVarDef,
-          js.TryCatch(
-            js.JSFunctionApply(bodyVarDef.ref, Nil),
-            exceptionVarIdent,
-            NoOriginalName,
-            js.JSFunctionApply(handlerVarDef.ref, List(exceptionVarRef))
-          )(jstpe.AnyType)
-        )
-
-      case WRAP_AS_THROWABLE =>
-        // js.special.wrapAsThrowable(arg)
-        js.WrapAsThrowable(genArgs1)
-
-      case UNWRAP_FROM_THROWABLE =>
-        // js.special.unwrapFromThrowable(arg)
-        js.UnwrapFromThrowable(genArgs1)
-
-      case UNION_FROM | UNION_FROM_TYPE_CONSTRUCTOR =>
-        /* js.|.from and js.|.fromTypeConstructor
-         * We should not have to deal with those. They have a perfectly valid
-         * user-space implementation. However, the Dotty type checker inserts
-         * way too many of those, even when they are completely unnecessary.
-         * That still wouldn't be an issue ... if only it did not insert them
-         * around the default getters to their parameters! But even there it
-         * does it (although the types are, by construction, *equivalent*!),
-         * and that kills our `UndefinedParam` treatment. So we have to handle
-         * those two methods as primitives to completely eliminate them.
-         *
-         * Hopefully this will become unnecessary when/if we manage to
-         * reinterpret js.| as a true Dotty union type.
-         */
-        genArgs2._1
-
-      case REFLECT_SELECTABLE_SELECTDYN =>
-        // scala.reflect.Selectable.selectDynamic
-        genReflectiveCall(tree, isSelectDynamic = true)
-      case REFLECT_SELECTABLE_APPLYDYN =>
-        // scala.reflect.Selectable.applyDynamic
-        genReflectiveCall(tree, isSelectDynamic = false)
-    }
-  }
-
-  /** Gen the SJSIR for a reflective call.
-   *
-   *  Reflective calls are calls to a structural type field or method that
-   *  involve a reflective Selectable. They look like the following in source
-   *  code:
-   *  {{{
-   *  import scala.reflect.Selectable.reflectiveSelectable
-   *
-   *  type Structural = {
-   *    val foo: Int
-   *    def bar(x: Int, y: String): String
-   *  }
-   *
-   *  val structural: Structural = new {
-   *    val foo: Int = 5
-   *    def bar(x: Int, y: String): String = x.toString + y
-   *  }
-   *
-   *  structural.foo
-   *  structural.bar(6, "hello")
-   *  }}}
-   *
-   *  After expansion by the Scala 3 rules for structural member selections and
-   *  calls, they look like
-   *
-   *  {{{
-   *  reflectiveSelectable(structural).selectDynamic("foo")
-   *  reflectiveSelectable(structural).applyDynamic("bar",
-   *    classOf[Int], classOf[String]
-   *  )(
-   *    6, "hello"
-   *  )
-   *  }}}
-   *
-   *  When the original `structural` value is already of a subtype of
-   *  `scala.reflect.Selectable`, there is no conversion involved. There could
-   *  also be any other arbitrary conversion, such as the deprecated bridge for
-   *  Scala 2's `import scala.language.reflectiveCalls`. In general, the shape
-   *  is therefore the following, for some `selectable: reflect.Selectable`:
-   *
-   *  {{{
-   *  selectable.selectDynamic("foo")
-   *  selectable.applyDynamic("bar",
-   *    classOf[Int], classOf[String]
-   *  )(
-   *    6, "hello"
-   *  )
-   *  }}}
-   *
-   *  and eventually reaches the back-end as
-   *
-   *  {{{
-   *  selectable.selectDynamic("foo") // same as above
-   *  selectable.applyDynamic("bar",
-   *    wrapRefArray([ classOf[Int], classOf[String] : jl.Class ]
-   *  )(
-   *    genericWrapArray([ Int.box(6), "hello" : Object ])
-   *  )
-   *  }}}
-   *
-   *  In SJSIR, they must be encoded as follows:
-   *
-   *  {{{
-   *  selectable.selectedValue;O().foo;R()
-   *  selectable.selectedValue;O().bar;I;Ljava.lang.String;R(
-   *    Int.box(6).asInstanceOf[int],
-   *    "hello".asInstanceOf[java.lang.String]
-   *  )
-   *  }}}
-   *
-   *  where `selectedValue;O()` is declared in `scala.reflect.Selectable` and
-   *  holds the actual instance on which to perform the reflective operations.
-   *  For the typical use case from the first snippet, it returns `structural`.
-   *
-   *  This means that we must deconstruct the elaborated calls to recover:
-   *
-   *  - the method name as a compile-time string `foo` or `bar`
-   *  - the `tp: Type`s that have been wrapped in `classOf[tp]`, as a
-   *    compile-time List[Type], from which we'll derive `jstpe.Type`s for the
-   *    `asInstanceOf`s and `jstpe.TypeRef`s for the `MethodName.reflectiveProxy`
-   *  - the actual arguments as a compile-time `List[Tree]`
-   *
-   *  Virtually all of the code in `genReflectiveCall` deals with recovering
-   *  those elements. Constructing the IR Tree is the easy part after that.
-   */
-  private def genReflectiveCall(tree: Apply, isSelectDynamic: Boolean): js.Tree = {
-    implicit val pos = tree.span
-    val Apply(fun @ Select(receiver, _), args) = tree: @unchecked
-
-    val selectedValueTree = js.Apply(js.ApplyFlags.empty, genExpr(receiver),
-        js.MethodIdent(selectedValueMethodName), Nil)(jstpe.AnyType)
-
-    // Extract the method name as a String
-    val methodNameStr = args.head match {
-      case Literal(Constants.Constant(name: String)) =>
-        name
-      case _ =>
-        report.error(
-            "The method name given to Selectable.selectDynamic or Selectable.applyDynamic " +
-            "must be a literal string. " +
-            "Other uses are not supported in Scala.js.",
-            args.head.sourcePos)
-        "erroneous"
-    }
-
-    val (formalParamTypeRefs, actualArgs) = if (isSelectDynamic) {
-      (Nil, Nil)
-    } else {
-      // Extract the param type refs and actual args from the 2nd and 3rd argument to applyDynamic
-      args.tail match {
-        case WrapArray(classOfsArray: JavaSeqLiteral) :: WrapArray(actualArgsAnyArray: JavaSeqLiteral) :: Nil =>
-          // Extract jstpe.Type's and jstpe.TypeRef's from the classOf[_] trees
-          val formalParamTypesAndTypeRefs = classOfsArray.elems.map {
-            // classOf[tp] -> tp
-            case Literal(const) if const.tag == Constants.ClazzTag =>
-              toIRTypeAndTypeRef(const.typeValue)
-            // Anything else is invalid
-            case otherTree =>
-              report.error(
-                  "The java.lang.Class[_] arguments passed to Selectable.applyDynamic must be " +
-                  "literal classOf[T] expressions (typically compiler-generated). " +
-                  "Other uses are not supported in Scala.js.",
-                  otherTree.sourcePos)
-              (jstpe.AnyType, jstpe.ClassRef(jsNames.ObjectClass))
-          }
-
-          // Gen the actual args, downcasting them to the formal param types
-          val actualArgs = actualArgsAnyArray.elems.zip(formalParamTypesAndTypeRefs).map {
-            (actualArgAny, formalParamTypeAndTypeRef) =>
-              val genActualArgAny = genExpr(actualArgAny)
-              genAsInstanceOf(genActualArgAny, formalParamTypeAndTypeRef._1)(genActualArgAny.pos)
-          }
-
-          (formalParamTypesAndTypeRefs.map(pair => toParamOrResultTypeRef(pair._2)), actualArgs)
-
-        case _ =>
-          report.error(
-              "Passing the varargs of Selectable.applyDynamic with `: _*` " +
-              "is not supported in Scala.js.",
-              tree.sourcePos)
-          (Nil, Nil)
-      }
-    }
-
-    val methodName = MethodName.reflectiveProxy(methodNameStr, formalParamTypeRefs)
-
-    js.Apply(js.ApplyFlags.empty, selectedValueTree, js.MethodIdent(methodName), actualArgs)(jstpe.AnyType)
-  }
-
-  /** Gen actual actual arguments to Scala method call.
-   *  Returns a list of the transformed arguments.
-   *
-   *  This tries to optimize repeated arguments (varargs) by turning them
-   *  into js.WrappedArray instead of Scala wrapped arrays.
-   */
-  private def genActualArgs(sym: Symbol, args: List[Tree])(
-      implicit pos: Position): List[js.Tree] = {
-    args.map(genExpr)
-    /*val wereRepeated = exitingPhase(currentRun.typerPhase) {
-      sym.tpe.params.map(p => isScalaRepeatedParamType(p.tpe))
-    }
-
-    if (wereRepeated.size > args.size) {
-      // Should not happen, but let's not crash
-      args.map(genExpr)
-    } else {
-      /* Arguments that are in excess compared to the type signature after
-       * erasure are lambda-lifted arguments. They cannot be repeated, hence
-       * the extension to `false`.
-       */
-      for ((arg, wasRepeated) <- args.zipAll(wereRepeated, EmptyTree, false)) yield {
-        if (wasRepeated) {
-          tryGenRepeatedParamAsJSArray(arg, handleNil = false).fold {
-            genExpr(arg)
-          } { genArgs =>
-            genNew(WrappedArrayClass, WrappedArray_ctor,
-                List(js.JSArrayConstr(genArgs)))
-          }
-        } else {
-          genExpr(arg)
-        }
-      }
-    }*/
-  }
-
-  /** Gen actual actual arguments to a JS method call.
-   *  Returns a list of the transformed arguments.
-   *
-   *  - TODO Repeated arguments (varargs) are expanded
-   *  - Default arguments are omitted or replaced by undefined
-   *  - All arguments are boxed
-   *
-   *  Repeated arguments that cannot be expanded at compile time (i.e., if a
-   *  Seq is passed to a varargs parameter with the syntax `seq: _*`) will be
-   *  wrapped in a [[js.JSSpread]] node to be expanded at runtime.
-   */
-  private def genActualJSArgs(sym: Symbol, args: List[Tree])(
-      implicit pos: Position): List[js.TreeOrJSSpread] = {
-
-    var reversedArgs: List[js.TreeOrJSSpread] = Nil
-
-    for ((arg, info) <- args.zip(sym.jsParamInfos)) {
-      if (info.repeated) {
-        reversedArgs = genJSRepeatedParam(arg) reverse_::: reversedArgs
-      } else if (info.capture) {
-        // Ignore captures
-        assert(sym.isClassConstructor,
-            i"Found a capture param in method ${sym.fullName}, which is not a class constructor, at $pos")
-      } else {
-        val unboxedArg = genExpr(arg)
-        val boxedArg = unboxedArg match {
-          case js.Transient(UndefinedParam) =>
-            unboxedArg
-          case _ =>
-            box(unboxedArg, info.info)
-        }
-        reversedArgs ::= boxedArg
-      }
-    }
-
-    /* Remove all consecutive UndefinedParam's at the end of the argument
-     * list. No check is performed whether they may be there, since they will
-     * only be placed where default arguments can be anyway.
-     */
-    reversedArgs = reversedArgs.dropWhile(_.isInstanceOf[js.Transient])
-
-    /* Find remaining UndefinedParam and replace by js.Undefined. This can
-     * happen with named arguments or with multiple argument lists.
-     */
-    reversedArgs = reversedArgs map {
-      case js.Transient(UndefinedParam) => js.Undefined()
-      case arg => arg
-    }
-
-    reversedArgs.reverse
-  }
-
-  /** Gen JS code for a repeated param of a JS method.
-   *
-   *  In this case `arg` has type `Seq[T]` for some `T`, but the result should
-   *  be an expanded list of the elements in the sequence. So this method
-   *  takes care of the conversion.
-   *
-   *  It is specialized for the shapes of tree generated by the desugaring
-   *  of repeated params in Scala, so that these are actually expanded at
-   *  compile-time.
-   *
-   *  Otherwise, it returns a `JSSpread` with the `Seq` converted to a
-   *  `js.Array`.
-   */
-  private def genJSRepeatedParam(arg: Tree): List[js.TreeOrJSSpread] = {
-    tryGenRepeatedParamAsJSArray(arg, handleNil = true).getOrElse {
-      /* Fall back to calling runtime.genTraversableOnce2jsArray
-       * to perform the conversion to js.Array, then wrap in a Spread
-       * operator.
-       */
-      implicit val pos: SourcePosition = arg.sourcePos
-      val jsArrayArg = genModuleApplyMethod(
-          jsdefn.Runtime_toJSVarArgs,
-          List(genExpr(arg)))
-      List(js.JSSpread(jsArrayArg))
-    }
-  }
-
-  /** Try and expand an actual argument to a repeated param `(xs: T*)`.
-   *
-   *  This method recognizes the shapes of tree generated by the desugaring
-   *  of repeated params in Scala, and expands them.
-   *  If `arg` does not have the shape of a generated repeated param, this
-   *  method returns `None`.
-   */
-  private def tryGenRepeatedParamAsJSArray(arg: Tree,
-      handleNil: Boolean): Option[List[js.Tree]] = {
-    implicit val pos = arg.span
-
-    // Given a method `def foo(args: T*)`
-    arg match {
-      // foo(arg1, arg2, ..., argN) where N > 0
-      case MaybeAsInstanceOf(WrapArray(MaybeAsInstanceOf(array: JavaSeqLiteral))) =>
-        /* Value classes in arrays are already boxed, so no need to use
-         * the type before erasure.
-         * TODO Is this true in dotty?
-         */
-        Some(array.elems.map(e => box(genExpr(e), e.tpe)))
-
-      // foo()
-      case Ident(_) if handleNil && arg.symbol == defn.NilModule =>
-        Some(Nil)
-
-      // foo(argSeq: _*) - cannot be optimized
-      case _ =>
-        None
-    }
-  }
-
-  private object MaybeAsInstanceOf {
-    def unapply(tree: Tree): Some[Tree] = tree match {
-      case TypeApply(asInstanceOf_? @ Select(base, _), _)
-          if asInstanceOf_?.symbol == defn.Any_asInstanceOf =>
-        Some(base)
-      case _ =>
-        Some(tree)
-    }
-  }
-
-  private object WrapArray {
-    lazy val isWrapArray: Set[Symbol] = {
-      val names0 = defn.ScalaValueClasses().map(sym => nme.wrapXArray(sym.name))
-      val names1 = names0 ++ Set(nme.wrapRefArray, nme.genericWrapArray)
-      val symsInPredef = names1.map(defn.ScalaPredefModule.requiredMethod(_))
-      val symsInScalaRunTime = names1.map(defn.ScalaRuntimeModule.requiredMethod(_))
-      (symsInPredef ++ symsInScalaRunTime).toSet
-    }
-
-    def unapply(tree: Apply): Option[Tree] = tree match {
-      case Apply(wrapArray_?, List(wrapped)) if isWrapArray(wrapArray_?.symbol) =>
-        Some(wrapped)
-      case _ =>
-        None
-    }
-  }
-
-  /** Wraps a `js.Array` to use as varargs. */
-  def genJSArrayToVarArgs(arrayRef: js.Tree)(implicit pos: SourcePosition): js.Tree =
-    genModuleApplyMethod(jsdefn.Runtime_toScalaVarArgs, List(arrayRef))
-
-  /** Gen the actual capture values for a JS constructor based on its fake `new` invocation. */
-  private def genCaptureValuesFromFakeNewInstance(tree: Tree): List[js.Tree] = {
-    implicit val pos: Position = tree.span
-
-    val Apply(fun @ Select(New(_), _), args) = tree: @unchecked
-    val sym = fun.symbol
-
-    /* We use the same strategy as genActualJSArgs to detect which parameters were
-     * introduced by explicitouter or lambdalift (but reversed, of course).
-     */
-
-    val existedBeforeUncurry = atPhase(elimRepeatedPhase) {
-      sym.info.paramNamess.flatten.toSet
-    }
-
-    for {
-      (arg, paramName) <- args.zip(sym.info.paramNamess.flatten)
-      if !existedBeforeUncurry(paramName)
-    } yield {
-      genExpr(arg)
-    }
-  }
-
-  private def genVarRef(sym: Symbol)(implicit pos: Position): js.VarRef =
-    js.VarRef(encodeLocalSym(sym))(toIRType(sym.info))
-
-  private def genAssignableField(sym: Symbol, qualifier: Tree)(implicit pos: SourcePosition): (js.AssignLhs, Boolean) = {
-    def qual = genExpr(qualifier)
-
-    if (sym.owner.isNonNativeJSClass) {
-      val f = if (sym.isJSExposed) {
-        js.JSSelect(qual, genExpr(sym.jsName))
-      } else if (sym.owner.isAnonymousClass) {
-        js.JSSelect(
-            js.JSSelect(qual, genPrivateFieldsSymbol()),
-            encodeFieldSymAsStringLiteral(sym))
-      } else {
-        js.JSPrivateSelect(qual, encodeClassName(sym.owner),
-            encodeFieldSym(sym))
-      }
-
-      (f, true)
-    } else if (sym.hasAnnotation(jsdefn.JSExportTopLevelAnnot)) {
-      val f = js.SelectStatic(encodeClassName(sym.owner), encodeFieldSym(sym))(jstpe.AnyType)
-      (f, true)
-    } else if (sym.hasAnnotation(jsdefn.JSExportStaticAnnot)) {
-      val jsName = sym.getAnnotation(jsdefn.JSExportStaticAnnot).get.argumentConstantString(0).getOrElse {
-        sym.defaultJSName
-      }
-      val companionClass = sym.owner.linkedClass
-      val f = js.JSSelect(genLoadJSConstructor(companionClass), js.StringLiteral(jsName))
-      (f, true)
-    } else {
-      val className = encodeClassName(sym.owner)
-      val fieldIdent = encodeFieldSym(sym)
-
-      /* #4370 Fields cannot have type NothingType, so we box them as
-       * scala.runtime.Nothing$ instead. They will be initialized with
-       * `null`, and any attempt to access them will throw a
-       * `ClassCastException` (generated in the unboxing code).
-       */
-      val (irType, boxed) = toIRType(sym.info) match
-        case jstpe.NothingType =>
-          (encodeClassType(defn.NothingClass), true)
-        case ftpe =>
-          (ftpe, false)
-
-      val f =
-        if sym.is(JavaStatic) then
-          js.SelectStatic(className, fieldIdent)(irType)
-        else
-          js.Select(qual, className, fieldIdent)(irType)
-
-      (f, boxed)
-    }
-  }
-
-  /** Gen JS code for loading a Java static field.
-   */
-  private def genLoadStaticField(sym: Symbol)(implicit pos: SourcePosition): js.Tree = {
-    /* Actually, there is no static member in Scala.js. If we come here, that
-     * is because we found the symbol in a Java-emitted .class in the
-     * classpath. But the corresponding implementation in Scala.js will
-     * actually be a val in the companion module.
-     */
-
-    if (sym == defn.BoxedUnit_UNIT) {
-      js.Undefined()
-    } else if (sym == defn.BoxedUnit_TYPE) {
-      js.ClassOf(jstpe.VoidRef)
-    } else {
-      val className = encodeClassName(sym.owner)
-      val method = encodeStaticMemberSym(sym)
-      js.ApplyStatic(js.ApplyFlags.empty, className, method, Nil)(toIRType(sym.info))
-    }
-  }
-
-  /** Generates a call to `runtime.privateFieldsSymbol()` */
-  private def genPrivateFieldsSymbol()(implicit pos: SourcePosition): js.Tree =
-    genModuleApplyMethod(jsdefn.Runtime_privateFieldsSymbol, Nil)
-
-  /** Generate loading of a module value.
-   *
-   *  Can be given either the module symbol or its module class symbol.
-   *
-   *  If the module we load refers to the global scope (i.e., it is
-   *  annotated with `@JSGlobalScope`), report a compile error specifying
-   *  that a global scope object should only be used as the qualifier of a
-   *  `.`-selection.
-   */
-  def genLoadModule(sym: Symbol)(implicit pos: SourcePosition): js.Tree =
-    ruleOutGlobalScope(genLoadModuleOrGlobalScope(sym))
-
-  /** Generate loading of a module value or the global scope.
-   *
-   *  Can be given either the module symbol of its module class symbol.
-   *
-   *  Unlike `genLoadModule`, this method does not fail if the module we load
-   *  refers to the global scope.
-   */
-  def genLoadModuleOrGlobalScope(sym0: Symbol)(
-      implicit pos: SourcePosition): MaybeGlobalScope = {
-
-    require(sym0.is(Module),
-        "genLoadModule called with non-module symbol: " + sym0)
-    val sym = if (sym0.isTerm) sym0.moduleClass else sym0
-
-    // Does that module refer to the global scope?
-    if (sym.hasAnnotation(jsdefn.JSGlobalScopeAnnot)) {
-      MaybeGlobalScope.GlobalScope(pos)
-    } else {
-      val cls = encodeClassName(sym)
-      val tree =
-        if (sym.isJSType) js.LoadJSModule(cls)
-        else js.LoadModule(cls)
-      MaybeGlobalScope.NotGlobalScope(tree)
-    }
-  }
-
-  /** Gen JS code representing the constructor of a JS class. */
-  private def genLoadJSConstructor(sym: Symbol)(
-      implicit pos: Position): js.Tree = {
-    assert(!isStaticModule(sym) && !sym.is(Trait),
-        s"genLoadJSConstructor called with non-class $sym")
-    js.LoadJSConstructor(encodeClassName(sym))
-  }
-
-  private inline val GenericGlobalObjectInformationMsg = {
-    "\n  " +
-    "See https://www.scala-js.org/doc/interoperability/global-scope.html " +
-    "for further information."
-  }
-
-  /** Rule out the `GlobalScope` case of a `MaybeGlobalScope` and extract the
-   *  value tree.
-   *
-   *  If `tree` represents the global scope, report a compile error.
-   */
-  private def ruleOutGlobalScope(tree: MaybeGlobalScope): js.Tree = {
-    tree match {
-      case MaybeGlobalScope.NotGlobalScope(t) =>
-        t
-      case MaybeGlobalScope.GlobalScope(pos) =>
-        reportErrorLoadGlobalScope()(pos)
-    }
-  }
-
-  /** Report a compile error specifying that the global scope cannot be
-   *  loaded as a value.
-   */
-  private def reportErrorLoadGlobalScope()(implicit pos: SourcePosition): js.Tree = {
-    report.error(
-        "Loading the global scope as a value (anywhere but as the " +
-        "left-hand-side of a `.`-selection) is not allowed." +
-        GenericGlobalObjectInformationMsg,
-        pos)
-    js.Undefined()
-  }
-
-  /** Gen a JS bracket select or a `JSGlobalRef`.
-   *
-   *  If the receiver is a normal value, i.e., not the global scope, then
-   *  emit a `JSSelect`.
-   *
-   *  Otherwise, if the `item` is a constant string that is a valid
-   *  JavaScript identifier, emit a `JSGlobalRef`.
-   *
-   *  Otherwise, report a compile error.
-   */
-  private def genJSSelectOrGlobalRef(qual: MaybeGlobalScope, item: js.Tree)(
-      implicit pos: SourcePosition): js.AssignLhs = {
-    qual match {
-      case MaybeGlobalScope.NotGlobalScope(qualTree) =>
-        js.JSSelect(qualTree, item)
-
-      case MaybeGlobalScope.GlobalScope(_) =>
-        item match {
-          case js.StringLiteral(value) =>
-            if (js.JSGlobalRef.isValidJSGlobalRefName(value)) {
-              js.JSGlobalRef(value)
-            } else if (js.JSGlobalRef.ReservedJSIdentifierNames.contains(value)) {
-              report.error(
-                  "Invalid selection in the global scope of the reserved " +
-                  s"identifier name `$value`." +
-                  GenericGlobalObjectInformationMsg,
-                  pos)
-              js.JSGlobalRef("erroneous")
-            } else {
-              report.error(
-                  "Selecting a field of the global scope whose name is " +
-                  "not a valid JavaScript identifier is not allowed." +
-                  GenericGlobalObjectInformationMsg,
-                  pos)
-              js.JSGlobalRef("erroneous")
-            }
-
-          case _ =>
-            report.error(
-                "Selecting a field of the global scope with a dynamic " +
-                "name is not allowed." +
-                GenericGlobalObjectInformationMsg,
-                pos)
-            js.JSGlobalRef("erroneous")
-        }
-    }
-  }
-
-  /** Gen a JS bracket method apply or an apply of a `GlobalRef`.
-   *
-   *  If the receiver is a normal value, i.e., not the global scope, then
-   *  emit a `JSMethodApply`.
-   *
-   *  Otherwise, if the `method` is a constant string that is a valid
-   *  JavaScript identifier, emit a `JSFunctionApply(JSGlobalRef(...), ...)`.
-   *
-   *  Otherwise, report a compile error.
-   */
-  private def genJSMethodApplyOrGlobalRefApply(
-      receiver: MaybeGlobalScope, method: js.Tree, args: List[js.TreeOrJSSpread])(
-      implicit pos: SourcePosition): js.Tree = {
-    receiver match {
-      case MaybeGlobalScope.NotGlobalScope(receiverTree) =>
-        js.JSMethodApply(receiverTree, method, args)
-
-      case MaybeGlobalScope.GlobalScope(_) =>
-        method match {
-          case js.StringLiteral(value) =>
-            if (js.JSGlobalRef.isValidJSGlobalRefName(value)) {
-              js.JSFunctionApply(js.JSGlobalRef(value), args)
-            } else if (js.JSGlobalRef.ReservedJSIdentifierNames.contains(value)) {
-              report.error(
-                  "Invalid call in the global scope of the reserved " +
-                  s"identifier name `$value`." +
-                  GenericGlobalObjectInformationMsg,
-                  pos)
-              js.Undefined()
-            } else {
-              report.error(
-                  "Calling a method of the global scope whose name is not " +
-                  "a valid JavaScript identifier is not allowed." +
-                  GenericGlobalObjectInformationMsg,
-                  pos)
-              js.Undefined()
-            }
-
-          case _ =>
-            report.error(
-                "Calling a method of the global scope with a dynamic " +
-                "name is not allowed." +
-                GenericGlobalObjectInformationMsg,
-                pos)
-            js.Undefined()
-        }
-    }
-  }
-
-  private def computeJSNativeLoadSpecOfValDef(sym: Symbol): js.JSNativeLoadSpec = {
-    atPhaseBeforeTransforms {
-      computeJSNativeLoadSpecOfInPhase(sym)
-    }
-  }
-
-  private def computeJSNativeLoadSpecOfClass(sym: Symbol): Option[js.JSNativeLoadSpec] = {
-    if (sym.is(Trait) || sym.hasAnnotation(jsdefn.JSGlobalScopeAnnot)) {
-      None
-    } else {
-      atPhaseBeforeTransforms {
-        if (sym.owner.isStaticOwner)
-          Some(computeJSNativeLoadSpecOfInPhase(sym))
-        else
-          None
-      }
-    }
-  }
-
-  private def computeJSNativeLoadSpecOfInPhase(sym: Symbol)(using Context): js.JSNativeLoadSpec = {
-    import js.JSNativeLoadSpec._
-
-    val symOwner = sym.owner
-
-    // Marks a code path as unexpected because it should have been reported as an error in `PrepJSInterop`.
-    def unexpected(msg: String): Nothing =
-      throw new FatalError(i"$msg for ${sym.fullName} at ${sym.srcPos}")
-
-    if (symOwner.hasAnnotation(jsdefn.JSNativeAnnot)) {
-      val jsName = sym.jsName match {
-        case JSName.Literal(jsName) => jsName
-        case JSName.Computed(_)     => unexpected("could not read the simple JS name as a string literal")
-      }
-
-      if (symOwner.hasAnnotation(jsdefn.JSGlobalScopeAnnot)) {
-        Global(jsName, Nil)
-      } else {
-        val ownerLoadSpec = computeJSNativeLoadSpecOfInPhase(symOwner)
-        ownerLoadSpec match {
-          case Global(globalRef, path) =>
-            Global(globalRef, path :+ jsName)
-          case Import(module, path) =>
-            Import(module, path :+ jsName)
-          case ImportWithGlobalFallback(Import(module, modulePath), Global(globalRef, globalPath)) =>
-            ImportWithGlobalFallback(
-                Import(module, modulePath :+ jsName),
-                Global(globalRef, globalPath :+ jsName))
-        }
-      }
-    } else {
-      def parsePath(pathName: String): List[String] =
-        pathName.split('.').toList
-
-      def parseGlobalPath(pathName: String): Global = {
-        val globalRef :: path = parsePath(pathName): @unchecked
-        Global(globalRef, path)
-      }
-
-      val annot = sym.annotations.find { annot =>
-        annot.symbol == jsdefn.JSGlobalAnnot || annot.symbol == jsdefn.JSImportAnnot
-      }.getOrElse {
-        unexpected("could not find the JS native load spec annotation")
-      }
-
-      if (annot.symbol == jsdefn.JSGlobalAnnot) {
-        val pathName = annot.argumentConstantString(0).getOrElse {
-          sym.defaultJSName
-        }
-        parseGlobalPath(pathName)
-      } else { // annot.symbol == jsdefn.JSImportAnnot
-        val module = annot.argumentConstantString(0).getOrElse {
-          unexpected("could not read the module argument as a string literal")
-        }
-        val path = annot.argumentConstantString(1).fold {
-          if (annot.arguments.sizeIs < 2)
-            parsePath(sym.defaultJSName)
-          else
-            Nil
-        } { pathName =>
-          parsePath(pathName)
-        }
-        val importSpec = Import(module, path)
-        annot.argumentConstantString(2).fold[js.JSNativeLoadSpec] {
-          importSpec
-        } { globalPathName =>
-          ImportWithGlobalFallback(importSpec, parseGlobalPath(globalPathName))
-        }
-      }
-    }
-  }
-
-  private def isMethodStaticInIR(sym: Symbol): Boolean =
-    sym.is(JavaStatic)
-
-  /** Generate a Class[_] value (e.g. coming from classOf[T]) */
-  private def genClassConstant(tpe: Type)(implicit pos: Position): js.Tree =
-    js.ClassOf(toTypeRef(tpe))
-
-  private def isStaticModule(sym: Symbol): Boolean =
-    sym.is(Module) && sym.isStatic
-
-  private def isPrimitiveValueType(tpe: Type): Boolean = {
-    tpe.widenDealias match {
-      case JavaArrayType(_)   => false
-      case _: ErasedValueType => false
-      case t                  => t.typeSymbol.asClass.isPrimitiveValueClass
-    }
-  }
-
-  protected lazy val isHijackedClass: Set[Symbol] = {
-    /* This list is a duplicate of ir.Definitions.HijackedClasses, but
-     * with global.Symbol's instead of IR encoded names as Strings.
-     * We also add java.lang.Void, which BoxedUnit "erases" to.
-     */
-    Set[Symbol](
-        defn.BoxedUnitClass, defn.BoxedBooleanClass, defn.BoxedCharClass, defn.BoxedByteClass,
-        defn.BoxedShortClass, defn.BoxedIntClass, defn.BoxedLongClass, defn.BoxedFloatClass,
-        defn.BoxedDoubleClass, defn.StringClass, jsdefn.JavaLangVoidClass
-    )
-  }
-
-  private def isMaybeJavaScriptException(tpe: Type): Boolean =
-    jsdefn.JavaScriptExceptionClass.isSubClass(tpe.typeSymbol)
-
-  private def hasDefaultCtorArgsAndJSModule(classSym: Symbol): Boolean = {
-    def hasNativeCompanion =
-      classSym.companionModule.moduleClass.hasAnnotation(jsdefn.JSNativeAnnot)
-    def hasDefaultParameters =
-      classSym.info.decls.exists(sym => sym.isClassConstructor && sym.hasDefaultParams)
-
-    hasNativeCompanion && hasDefaultParameters
-  }
-
-  // Copied from DottyBackendInterface
-
-  private val desugared = new java.util.IdentityHashMap[Type, tpd.Select]
-
-  def desugarIdent(i: Ident): Option[tpd.Select] = {
-    var found = desugared.get(i.tpe)
-    if (found == null) {
-      tpd.desugarIdent(i) match {
-        case sel: tpd.Select =>
-          desugared.put(i.tpe, sel)
-          found = sel
-        case _ =>
-      }
-    }
-    if (found == null) None else Some(found)
-  }
-}
-
-object JSCodeGen {
-
-  private val NullPointerExceptionClass = ClassName("java.lang.NullPointerException")
-  private val JSObjectClassName = ClassName("scala.scalajs.js.Object")
-  private val JavaScriptExceptionClassName = ClassName("scala.scalajs.js.JavaScriptException")
-
-  private val ObjectClassRef = jstpe.ClassRef(ir.Names.ObjectClass)
-
-  private val newSimpleMethodName = SimpleMethodName("new")
-
-  private val selectedValueMethodName = MethodName("selectedValue", Nil, ObjectClassRef)
-
-  private val ObjectArgConstructorName = MethodName.constructor(List(ObjectClassRef))
-
-  private val thisOriginalName = OriginalName("this")
-
-  sealed abstract class MaybeGlobalScope
-
-  object MaybeGlobalScope {
-    final case class NotGlobalScope(tree: js.Tree) extends MaybeGlobalScope
-
-    final case class GlobalScope(pos: SourcePosition) extends MaybeGlobalScope
-  }
-
-  /** Marker object for undefined parameters in JavaScript semantic calls.
-   *
-   *  To be used inside a `js.Transient` node.
-   */
-  case object UndefinedParam extends js.Transient.Value {
-    val tpe: jstpe.Type = jstpe.UndefType
-
-    def traverse(traverser: ir.Traversers.Traverser): Unit = ()
-
-    def transform(transformer: ir.Transformers.Transformer, isStat: Boolean)(
-        implicit pos: ir.Position): js.Tree = {
-      js.Transient(this)
-    }
-
-    def printIR(out: ir.Printers.IRTreePrinter): Unit =
-      out.print("<undefined-param>")
-  }
-
-  /** Info about a default param accessor.
-   *
-   *  The method must have a default getter name for this class to make sense.
-   */
-  private class DefaultParamInfo(sym: Symbol)(using Context) {
-    private val methodName = sym.name.exclude(DefaultGetterName)
-
-    def isForConstructor: Boolean = methodName == nme.CONSTRUCTOR
-
-    /** When `isForConstructor` is true, returns the owner of the attached
-     *  constructor.
-     */
-    def constructorOwner: Symbol = sym.owner.linkedClass
-
-    /** When `isForConstructor` is false, returns the method attached to the
-     *  specified default accessor.
-     */
-    def attachedMethod: Symbol = {
-      // If there are overloads, we need to find the one that has default params.
-      val overloads = sym.owner.info.decl(methodName)
-      if (!overloads.isOverloaded)
-        overloads.symbol
-      else
-        overloads.suchThat(_.is(HasDefaultParams, butNot = Bridge)).symbol
-    }
-  }
-
-}
diff --git a/tests/pos-with-compiler-cc/backend/sjs/JSDefinitions.scala b/tests/pos-with-compiler-cc/backend/sjs/JSDefinitions.scala
deleted file mode 100644
index 964811c69e19..000000000000
--- a/tests/pos-with-compiler-cc/backend/sjs/JSDefinitions.scala
+++ /dev/null
@@ -1,340 +0,0 @@
-package dotty.tools.backend.sjs
-
-import scala.language.unsafeNulls
-
-import scala.annotation.threadUnsafe
-
-import dotty.tools.dotc.core._
-import Names._
-import Types._
-import Contexts._
-import Symbols._
-import StdNames._
-
-import dotty.tools.dotc.config.SJSPlatform
-
-object JSDefinitions {
-  /** The Scala.js-specific definitions for the current context. */
-  def jsdefn(using Context): JSDefinitions =
-    ctx.platform.asInstanceOf[SJSPlatform].jsDefinitions
-}
-
-final class JSDefinitions()(using DetachedContext) {
-
-  @threadUnsafe lazy val InlineAnnotType: TypeRef = requiredClassRef("scala.inline")
-  def InlineAnnot(using Context) = InlineAnnotType.symbol.asClass
-  @threadUnsafe lazy val NoinlineAnnotType: TypeRef = requiredClassRef("scala.noinline")
-  def NoinlineAnnot(using Context) = NoinlineAnnotType.symbol.asClass
-
-  @threadUnsafe lazy val JavaLangVoidType: TypeRef = requiredClassRef("java.lang.Void")
-  def JavaLangVoidClass(using Context) = JavaLangVoidType.symbol.asClass
-
-  @threadUnsafe lazy val ScalaJSJSPackageVal = requiredPackage("scala.scalajs.js")
-  @threadUnsafe lazy val ScalaJSJSPackageClass = ScalaJSJSPackageVal.moduleClass.asClass
-    @threadUnsafe lazy val JSPackage_typeOfR = ScalaJSJSPackageClass.requiredMethodRef("typeOf")
-    def JSPackage_typeOf(using Context) = JSPackage_typeOfR.symbol
-    @threadUnsafe lazy val JSPackage_constructorOfR = ScalaJSJSPackageClass.requiredMethodRef("constructorOf")
-    def JSPackage_constructorOf(using Context) = JSPackage_constructorOfR.symbol
-    @threadUnsafe lazy val JSPackage_nativeR = ScalaJSJSPackageClass.requiredMethodRef("native")
-    def JSPackage_native(using Context) = JSPackage_nativeR.symbol
-    @threadUnsafe lazy val JSPackage_undefinedR = ScalaJSJSPackageClass.requiredMethodRef("undefined")
-    def JSPackage_undefined(using Context) = JSPackage_undefinedR.symbol
-    @threadUnsafe lazy val JSPackage_dynamicImportR = ScalaJSJSPackageClass.requiredMethodRef("dynamicImport")
-    def JSPackage_dynamicImport(using Context) = JSPackage_dynamicImportR.symbol
-
-  @threadUnsafe lazy val JSNativeAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.native")
-  def JSNativeAnnot(using Context) = JSNativeAnnotType.symbol.asClass
-
-  @threadUnsafe lazy val JSAnyType: TypeRef = requiredClassRef("scala.scalajs.js.Any")
-  def JSAnyClass(using Context) = JSAnyType.symbol.asClass
-  @threadUnsafe lazy val JSObjectType: TypeRef = requiredClassRef("scala.scalajs.js.Object")
-  def JSObjectClass(using Context) = JSObjectType.symbol.asClass
-  @threadUnsafe lazy val JSFunctionType: TypeRef = requiredClassRef("scala.scalajs.js.Function")
-  def JSFunctionClass(using Context) = JSFunctionType.symbol.asClass
-  @threadUnsafe lazy val JSThisFunctionType: TypeRef = requiredClassRef("scala.scalajs.js.ThisFunction")
-  def JSThisFunctionClass(using Context) = JSThisFunctionType.symbol.asClass
-
-  @threadUnsafe lazy val PseudoUnionType: TypeRef = requiredClassRef("scala.scalajs.js.|")
-  def PseudoUnionClass(using Context) = PseudoUnionType.symbol.asClass
-
-  @threadUnsafe lazy val PseudoUnionModuleRef = requiredModuleRef("scala.scalajs.js.|")
-  def PseudoUnionModule(using Context) = PseudoUnionModuleRef.symbol
-    @threadUnsafe lazy val PseudoUnion_fromR = PseudoUnionModule.requiredMethodRef("from")
-    def PseudoUnion_from(using Context) = PseudoUnion_fromR.symbol
-    @threadUnsafe lazy val PseudoUnion_fromTypeConstructorR = PseudoUnionModule.requiredMethodRef("fromTypeConstructor")
-    def PseudoUnion_fromTypeConstructor(using Context) = PseudoUnion_fromTypeConstructorR.symbol
-
-  @threadUnsafe lazy val UnionOpsModuleRef = requiredModuleRef("scala.scalajs.js.internal.UnitOps")
-
-  @threadUnsafe lazy val JSArrayType: TypeRef = requiredClassRef("scala.scalajs.js.Array")
-  def JSArrayClass(using Context) = JSArrayType.symbol.asClass
-  @threadUnsafe lazy val JSDynamicType: TypeRef = requiredClassRef("scala.scalajs.js.Dynamic")
-  def JSDynamicClass(using Context) = JSDynamicType.symbol.asClass
-
-  @threadUnsafe lazy val RuntimeExceptionType: TypeRef = requiredClassRef("java.lang.RuntimeException")
-  def RuntimeExceptionClass(using Context) = RuntimeExceptionType.symbol.asClass
-  @threadUnsafe lazy val JavaScriptExceptionType: TypeRef = requiredClassRef("scala.scalajs.js.JavaScriptException")
-  def JavaScriptExceptionClass(using Context) = JavaScriptExceptionType.symbol.asClass
-
-  @threadUnsafe lazy val JSGlobalAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSGlobal")
-  def JSGlobalAnnot(using Context) = JSGlobalAnnotType.symbol.asClass
-  @threadUnsafe lazy val JSImportAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSImport")
-  def JSImportAnnot(using Context) = JSImportAnnotType.symbol.asClass
-  @threadUnsafe lazy val JSGlobalScopeAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSGlobalScope")
-  def JSGlobalScopeAnnot(using Context) = JSGlobalScopeAnnotType.symbol.asClass
-  @threadUnsafe lazy val JSNameAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSName")
-  def JSNameAnnot(using Context) = JSNameAnnotType.symbol.asClass
-  @threadUnsafe lazy val JSFullNameAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSFullName")
-  def JSFullNameAnnot(using Context) = JSFullNameAnnotType.symbol.asClass
-  @threadUnsafe lazy val JSBracketAccessAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSBracketAccess")
-  def JSBracketAccessAnnot(using Context) = JSBracketAccessAnnotType.symbol.asClass
-  @threadUnsafe lazy val JSBracketCallAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSBracketCall")
-  def JSBracketCallAnnot(using Context) = JSBracketCallAnnotType.symbol.asClass
-  @threadUnsafe lazy val JSExportTopLevelAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSExportTopLevel")
-  def JSExportTopLevelAnnot(using Context) = JSExportTopLevelAnnotType.symbol.asClass
-  @threadUnsafe lazy val JSExportAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSExport")
-  def JSExportAnnot(using Context) = JSExportAnnotType.symbol.asClass
-  @threadUnsafe lazy val JSExportStaticAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSExportStatic")
-  def JSExportStaticAnnot(using Context) = JSExportStaticAnnotType.symbol.asClass
-  @threadUnsafe lazy val JSExportAllAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSExportAll")
-  def JSExportAllAnnot(using Context) = JSExportAllAnnotType.symbol.asClass
-
-  def JSAnnotPackage(using Context) = JSGlobalAnnot.owner.asClass
-
-  @threadUnsafe lazy val JSTypeAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.internal.JSType")
-  def JSTypeAnnot(using Context) = JSTypeAnnotType.symbol.asClass
-  @threadUnsafe lazy val JSOptionalAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.internal.JSOptional")
-  def JSOptionalAnnot(using Context) = JSOptionalAnnotType.symbol.asClass
-  @threadUnsafe lazy val ExposedJSMemberAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.internal.ExposedJSMember")
-  def ExposedJSMemberAnnot(using Context) = ExposedJSMemberAnnotType.symbol.asClass
-
-  @threadUnsafe lazy val JSImportNamespaceModuleRef = requiredModuleRef("scala.scalajs.js.annotation.JSImport.Namespace")
-  def JSImportNamespaceModule(using Context) = JSImportNamespaceModuleRef.symbol
-
-  @threadUnsafe lazy val JSAnyModuleRef = requiredModuleRef("scala.scalajs.js.Any")
-  def JSAnyModule(using Context) = JSAnyModuleRef.symbol
-    @threadUnsafe lazy val JSAny_fromFunctionR = (0 to 22).map(n => JSAnyModule.requiredMethodRef("fromFunction" + n)).toArray
-    def JSAny_fromFunction(n: Int)(using Context) = JSAny_fromFunctionR(n).symbol
-
-  @threadUnsafe lazy val JSDynamicModuleRef = requiredModuleRef("scala.scalajs.js.Dynamic")
-  def JSDynamicModule(using Context) = JSDynamicModuleRef.symbol
-    @threadUnsafe lazy val JSDynamic_globalR = JSDynamicModule.requiredMethodRef("global")
-    def JSDynamic_global(using Context) = JSDynamic_globalR.symbol
-    @threadUnsafe lazy val JSDynamic_newInstanceR = JSDynamicModule.requiredMethodRef("newInstance")
-    def JSDynamic_newInstance(using Context) = JSDynamic_newInstanceR.symbol
-
-  @threadUnsafe lazy val JSDynamicLiteralModuleRef = JSDynamicModule.moduleClass.requiredValueRef("literal")
-  def JSDynamicLiteralModule(using Context) = JSDynamicLiteralModuleRef.symbol
-    @threadUnsafe lazy val JSDynamicLiteral_applyDynamicNamedR = JSDynamicLiteralModule.requiredMethodRef("applyDynamicNamed")
-    def JSDynamicLiteral_applyDynamicNamed(using Context) = JSDynamicLiteral_applyDynamicNamedR.symbol
-    @threadUnsafe lazy val JSDynamicLiteral_applyDynamicR = JSDynamicLiteralModule.requiredMethodRef("applyDynamic")
-    def JSDynamicLiteral_applyDynamic(using Context) = JSDynamicLiteral_applyDynamicR.symbol
-
-  @threadUnsafe lazy val JSObjectModuleRef = requiredModuleRef("scala.scalajs.js.Object")
-  def JSObjectModule(using Context) = JSObjectModuleRef.symbol
-
-  @threadUnsafe lazy val JSArrayModuleRef = requiredModuleRef("scala.scalajs.js.Array")
-  def JSArrayModule(using Context) = JSArrayModuleRef.symbol
-    @threadUnsafe lazy val JSArray_applyR = JSArrayModule.requiredMethodRef(nme.apply)
-    def JSArray_apply(using Context) = JSArray_applyR.symbol
-
-  @threadUnsafe lazy val JSThisFunctionModuleRef = requiredModuleRef("scala.scalajs.js.ThisFunction")
-  def JSThisFunctionModule(using Context) = JSThisFunctionModuleRef.symbol
-    @threadUnsafe lazy val JSThisFunction_fromFunctionR = (1 to 22).map(n => JSThisFunctionModule.requiredMethodRef("fromFunction" + n)).toArray
-    def JSThisFunction_fromFunction(n: Int)(using Context) = JSThisFunction_fromFunctionR(n - 1).symbol
-
-  @threadUnsafe lazy val JSConstructorTagModuleRef = requiredModuleRef("scala.scalajs.js.ConstructorTag")
-  def JSConstructorTagModule(using Context) = JSConstructorTagModuleRef.symbol
-    @threadUnsafe lazy val JSConstructorTag_materializeR = JSConstructorTagModule.requiredMethodRef("materialize")
-    def JSConstructorTag_materialize(using Context) = JSConstructorTag_materializeR.symbol
-
-  @threadUnsafe lazy val JSNewModuleRef = requiredModuleRef("scala.scalajs.js.new")
-  def JSNewModule(using Context) = JSNewModuleRef.symbol
-    @threadUnsafe lazy val JSNew_targetR = JSNewModule.requiredMethodRef("target")
-    def JSNew_target(using Context) = JSNew_targetR.symbol
-
-  @threadUnsafe lazy val JSImportModuleRef = requiredModuleRef("scala.scalajs.js.import")
-  def JSImportModule(using Context) = JSImportModuleRef.symbol
-    @threadUnsafe lazy val JSImport_applyR = JSImportModule.requiredMethodRef(nme.apply)
-    def JSImport_apply(using Context) = JSImport_applyR.symbol
-    @threadUnsafe lazy val JSImport_metaR = JSImportModule.requiredMethodRef("meta")
-    def JSImport_meta(using Context) = JSImport_metaR.symbol
-
-  @threadUnsafe lazy val RuntimePackageVal = requiredPackage("scala.scalajs.runtime")
-  @threadUnsafe lazy val RuntimePackageClass = RuntimePackageVal.moduleClass.asClass
-    @threadUnsafe lazy val Runtime_toScalaVarArgsR = RuntimePackageClass.requiredMethodRef("toScalaVarArgs")
-    def Runtime_toScalaVarArgs(using Context) = Runtime_toScalaVarArgsR.symbol
-    @threadUnsafe lazy val Runtime_toJSVarArgsR = RuntimePackageClass.requiredMethodRef("toJSVarArgs")
-    def Runtime_toJSVarArgs(using Context) = Runtime_toJSVarArgsR.symbol
-    @threadUnsafe lazy val Runtime_privateFieldsSymbolR = RuntimePackageClass.requiredMethodRef("privateFieldsSymbol")
-    def Runtime_privateFieldsSymbol(using Context) = Runtime_privateFieldsSymbolR.symbol
-    @threadUnsafe lazy val Runtime_constructorOfR = RuntimePackageClass.requiredMethodRef("constructorOf")
-    def Runtime_constructorOf(using Context) = Runtime_constructorOfR.symbol
-    @threadUnsafe lazy val Runtime_newConstructorTagR = RuntimePackageClass.requiredMethodRef("newConstructorTag")
-    def Runtime_newConstructorTag(using Context) = Runtime_newConstructorTagR.symbol
-    @threadUnsafe lazy val Runtime_createInnerJSClassR = RuntimePackageClass.requiredMethodRef("createInnerJSClass")
-    def Runtime_createInnerJSClass(using Context) = Runtime_createInnerJSClassR.symbol
-    @threadUnsafe lazy val Runtime_createLocalJSClassR = RuntimePackageClass.requiredMethodRef("createLocalJSClass")
-    def Runtime_createLocalJSClass(using Context) = Runtime_createLocalJSClassR.symbol
-    @threadUnsafe lazy val Runtime_withContextualJSClassValueR = RuntimePackageClass.requiredMethodRef("withContextualJSClassValue")
-    def Runtime_withContextualJSClassValue(using Context) = Runtime_withContextualJSClassValueR.symbol
-    @threadUnsafe lazy val Runtime_linkingInfoR = RuntimePackageClass.requiredMethodRef("linkingInfo")
-    def Runtime_linkingInfo(using Context) = Runtime_linkingInfoR.symbol
-    @threadUnsafe lazy val Runtime_dynamicImportR = RuntimePackageClass.requiredMethodRef("dynamicImport")
-    def Runtime_dynamicImport(using Context) = Runtime_dynamicImportR.symbol
-
-  @threadUnsafe lazy val DynamicImportThunkType: TypeRef = requiredClassRef("scala.scalajs.runtime.DynamicImportThunk")
-  def DynamicImportThunkClass(using Context) = DynamicImportThunkType.symbol.asClass
-    @threadUnsafe lazy val DynamicImportThunkClass_applyR = DynamicImportThunkClass.requiredMethodRef(nme.apply)
-    def DynamicImportThunkClass_apply(using Context) = DynamicImportThunkClass_applyR.symbol
-
-  @threadUnsafe lazy val SpecialPackageVal = requiredPackage("scala.scalajs.js.special")
-  @threadUnsafe lazy val SpecialPackageClass = SpecialPackageVal.moduleClass.asClass
-    @threadUnsafe lazy val Special_debuggerR = SpecialPackageClass.requiredMethodRef("debugger")
-    def Special_debugger(using Context) = Special_debuggerR.symbol
-    @threadUnsafe lazy val Special_deleteR = SpecialPackageClass.requiredMethodRef("delete")
-    def Special_delete(using Context) = Special_deleteR.symbol
-    @threadUnsafe lazy val Special_forinR = SpecialPackageClass.requiredMethodRef("forin")
-    def Special_forin(using Context) = Special_forinR.symbol
-    @threadUnsafe lazy val Special_inR = SpecialPackageClass.requiredMethodRef("in")
-    def Special_in(using Context) = Special_inR.symbol
-    @threadUnsafe lazy val Special_instanceofR = SpecialPackageClass.requiredMethodRef("instanceof")
-    def Special_instanceof(using Context) = Special_instanceofR.symbol
-    @threadUnsafe lazy val Special_strictEqualsR = SpecialPackageClass.requiredMethodRef("strictEquals")
-    def Special_strictEquals(using Context) = Special_strictEqualsR.symbol
-    @threadUnsafe lazy val Special_throwR = SpecialPackageClass.requiredMethodRef("throw")
-    def Special_throw(using Context) = Special_throwR.symbol
-    @threadUnsafe lazy val Special_tryCatchR = SpecialPackageClass.requiredMethodRef("tryCatch")
-    def Special_tryCatch(using Context) = Special_tryCatchR.symbol
-    @threadUnsafe lazy val Special_wrapAsThrowableR = SpecialPackageClass.requiredMethodRef("wrapAsThrowable")
-    def Special_wrapAsThrowable(using Context) = Special_wrapAsThrowableR.symbol
-    @threadUnsafe lazy val Special_unwrapFromThrowableR = SpecialPackageClass.requiredMethodRef("unwrapFromThrowable")
-    def Special_unwrapFromThrowable(using Context) = Special_unwrapFromThrowableR.symbol
-
-  @threadUnsafe lazy val WrappedArrayType: TypeRef = requiredClassRef("scala.scalajs.js.WrappedArray")
-  def WrappedArrayClass(using Context) = WrappedArrayType.symbol.asClass
-
-  @threadUnsafe lazy val ScalaRunTime_isArrayR = defn.ScalaRuntimeModule.requiredMethodRef("isArray", List(???, ???))
-  def ScalaRunTime_isArray(using Context): Symbol = ScalaRunTime_isArrayR.symbol
-
-  @threadUnsafe lazy val BoxesRunTime_boxToCharacterR = defn.BoxesRunTimeModule.requiredMethodRef("boxToCharacter")
-  def BoxesRunTime_boxToCharacter(using Context): Symbol = BoxesRunTime_boxToCharacterR.symbol
-  @threadUnsafe lazy val BoxesRunTime_unboxToCharR = defn.BoxesRunTimeModule.requiredMethodRef("unboxToChar")
-  def BoxesRunTime_unboxToChar(using Context): Symbol = BoxesRunTime_unboxToCharR.symbol
-
-  @threadUnsafe lazy val EnableReflectiveInstantiationAnnotType: TypeRef = requiredClassRef("scala.scalajs.reflect.annotation.EnableReflectiveInstantiation")
-  def EnableReflectiveInstantiationAnnot(using Context) = EnableReflectiveInstantiationAnnotType.symbol.asClass
-
-  @threadUnsafe lazy val ReflectModuleRef = requiredModuleRef("scala.scalajs.reflect.Reflect")
-  def ReflectModule(using Context) = ReflectModuleRef.symbol
-    @threadUnsafe lazy val Reflect_registerLoadableModuleClassR = ReflectModule.requiredMethodRef("registerLoadableModuleClass")
-    def Reflect_registerLoadableModuleClass(using Context) = Reflect_registerLoadableModuleClassR.symbol
-    @threadUnsafe lazy val Reflect_registerInstantiatableClassR = ReflectModule.requiredMethodRef("registerInstantiatableClass")
-    def Reflect_registerInstantiatableClass(using Context) = Reflect_registerInstantiatableClassR.symbol
-
-  @threadUnsafe lazy val ReflectSelectableType: TypeRef = requiredClassRef("scala.reflect.Selectable")
-  def ReflectSelectableClass(using Context) = ReflectSelectableType.symbol.asClass
-    @threadUnsafe lazy val ReflectSelectable_selectDynamicR = ReflectSelectableClass.requiredMethodRef("selectDynamic")
-    def ReflectSelectable_selectDynamic(using Context) = ReflectSelectable_selectDynamicR.symbol
-    @threadUnsafe lazy val ReflectSelectable_applyDynamicR = ReflectSelectableClass.requiredMethodRef("applyDynamic")
-    def ReflectSelectable_applyDynamic(using Context) = ReflectSelectable_applyDynamicR.symbol
-
-  @threadUnsafe lazy val ReflectSelectableModuleRef = requiredModuleRef("scala.reflect.Selectable")
-  def ReflectSelectableModule(using Context) = ReflectSelectableModuleRef.symbol
-    @threadUnsafe lazy val ReflectSelectable_reflectiveSelectableR = ReflectSelectableModule.requiredMethodRef("reflectiveSelectable")
-    def ReflectSelectable_reflectiveSelectable(using Context) = ReflectSelectable_reflectiveSelectableR.symbol
-
-  @threadUnsafe lazy val SelectableModuleRef = requiredModuleRef("scala.Selectable")
-  def SelectableModule(using Context) = SelectableModuleRef.symbol
-    @threadUnsafe lazy val Selectable_reflectiveSelectableFromLangReflectiveCallsR = SelectableModule.requiredMethodRef("reflectiveSelectableFromLangReflectiveCalls")
-    def Selectable_reflectiveSelectableFromLangReflectiveCalls(using Context) = Selectable_reflectiveSelectableFromLangReflectiveCallsR.symbol
-
-  private var allRefClassesCache: Set[Symbol] = _
-  def allRefClasses(using Context): Set[Symbol] = {
-    if (allRefClassesCache == null) {
-      val baseNames = List("Object", "Boolean", "Character", "Byte", "Short",
-          "Int", "Long", "Float", "Double")
-      val fullNames = baseNames.flatMap { base =>
-        List(s"scala.runtime.${base}Ref", s"scala.runtime.Volatile${base}Ref")
-      }
-      allRefClassesCache = fullNames.map(name => requiredClass(name)).toSet
-    }
-    allRefClassesCache
-  }
-
-  /** Definitions related to scala.Enumeration. */
-  object scalaEnumeration {
-    val nmeValue = termName("Value")
-    val nmeVal = termName("Val")
-    val hasNext = termName("hasNext")
-    val next = termName("next")
-
-    @threadUnsafe lazy val EnumerationClass = requiredClass("scala.Enumeration")
-      @threadUnsafe lazy val Enumeration_Value_NoArg = EnumerationClass.requiredValue(nmeValue)
-      @threadUnsafe lazy val Enumeration_Value_IntArg = EnumerationClass.requiredMethod(nmeValue, List(defn.IntType))
-      @threadUnsafe lazy val Enumeration_Value_StringArg = EnumerationClass.requiredMethod(nmeValue, List(defn.StringType))
-      @threadUnsafe lazy val Enumeration_Value_IntStringArg = EnumerationClass.requiredMethod(nmeValue, List(defn.IntType, defn.StringType))
-      @threadUnsafe lazy val Enumeration_nextName = EnumerationClass.requiredMethod(termName("nextName"))
-
-    @threadUnsafe lazy val EnumerationValClass = EnumerationClass.requiredClass("Val")
-      @threadUnsafe lazy val Enumeration_Val_NoArg = EnumerationValClass.requiredMethod(nme.CONSTRUCTOR, Nil)
-      @threadUnsafe lazy val Enumeration_Val_IntArg = EnumerationValClass.requiredMethod(nme.CONSTRUCTOR, List(defn.IntType))
-      @threadUnsafe lazy val Enumeration_Val_StringArg = EnumerationValClass.requiredMethod(nme.CONSTRUCTOR, List(defn.StringType))
-      @threadUnsafe lazy val Enumeration_Val_IntStringArg = EnumerationValClass.requiredMethod(nme.CONSTRUCTOR, List(defn.IntType, defn.StringType))
-
-    def isValueMethod(sym: Symbol)(using Context): Boolean =
-      sym.name == nmeValue && sym.owner == EnumerationClass
-
-    def isValueMethodNoName(sym: Symbol)(using Context): Boolean =
-      isValueMethod(sym) && (sym == Enumeration_Value_NoArg || sym == Enumeration_Value_IntArg)
-
-    def isValueMethodName(sym: Symbol)(using Context): Boolean =
-      isValueMethod(sym) && (sym == Enumeration_Value_StringArg || sym == Enumeration_Value_IntStringArg)
-
-    def isValCtor(sym: Symbol)(using Context): Boolean =
-      sym.isClassConstructor && sym.owner == EnumerationValClass
-
-    def isValCtorNoName(sym: Symbol)(using Context): Boolean =
-      isValCtor(sym) && (sym == Enumeration_Val_NoArg || sym == Enumeration_Val_IntArg)
-
-    def isValCtorName(sym: Symbol)(using Context): Boolean =
-      isValCtor(sym) && (sym == Enumeration_Val_StringArg || sym == Enumeration_Val_IntStringArg)
-  }
-
-  /** Definitions related to the treatment of JUnit bootstrappers. */
-  object junit {
-    @threadUnsafe lazy val TestAnnotType: TypeRef = requiredClassRef("org.junit.Test")
-    def TestAnnotClass(using Context): ClassSymbol = TestAnnotType.symbol.asClass
-
-    @threadUnsafe lazy val BeforeAnnotType: TypeRef = requiredClassRef("org.junit.Before")
-    def BeforeAnnotClass(using Context): ClassSymbol = BeforeAnnotType.symbol.asClass
-
-    @threadUnsafe lazy val AfterAnnotType: TypeRef = requiredClassRef("org.junit.After")
-    def AfterAnnotClass(using Context): ClassSymbol = AfterAnnotType.symbol.asClass
-
-    @threadUnsafe lazy val BeforeClassAnnotType: TypeRef = requiredClassRef("org.junit.BeforeClass")
-    def BeforeClassAnnotClass(using Context): ClassSymbol = BeforeClassAnnotType.symbol.asClass
-
-    @threadUnsafe lazy val AfterClassAnnotType: TypeRef = requiredClassRef("org.junit.AfterClass")
-    def AfterClassAnnotClass(using Context): ClassSymbol = AfterClassAnnotType.symbol.asClass
-
-    @threadUnsafe lazy val IgnoreAnnotType: TypeRef = requiredClassRef("org.junit.Ignore")
-    def IgnoreAnnotClass(using Context): ClassSymbol = IgnoreAnnotType.symbol.asClass
-
-    @threadUnsafe lazy val BootstrapperType: TypeRef = requiredClassRef("org.scalajs.junit.Bootstrapper")
-
-    @threadUnsafe lazy val TestMetadataType: TypeRef = requiredClassRef("org.scalajs.junit.TestMetadata")
-
-    @threadUnsafe lazy val NoSuchMethodExceptionType: TypeRef = requiredClassRef("java.lang.NoSuchMethodException")
-
-    @threadUnsafe lazy val FutureType: TypeRef = requiredClassRef("scala.concurrent.Future")
-    def FutureClass(using Context): ClassSymbol = FutureType.symbol.asClass
-
-    @threadUnsafe private lazy val FutureModule_successfulR = requiredModule("scala.concurrent.Future").requiredMethodRef("successful")
-    def FutureModule_successful(using Context): Symbol = FutureModule_successfulR.symbol
-
-    @threadUnsafe private lazy val SuccessModule_applyR = requiredModule("scala.util.Success").requiredMethodRef(nme.apply)
-    def SuccessModule_apply(using Context): Symbol = SuccessModule_applyR.symbol
-  }
-
-}
diff --git a/tests/pos-with-compiler-cc/backend/sjs/JSEncoding.scala b/tests/pos-with-compiler-cc/backend/sjs/JSEncoding.scala
deleted file mode 100644
index 518295543610..000000000000
--- a/tests/pos-with-compiler-cc/backend/sjs/JSEncoding.scala
+++ /dev/null
@@ -1,428 +0,0 @@
-package dotty.tools.backend.sjs
-
-import scala.language.unsafeNulls
-
-import scala.collection.mutable
-
-import dotty.tools.dotc.core._
-import Contexts._
-import Flags._
-import Types._
-import Symbols._
-import NameOps._
-import Names._
-import StdNames._
-
-import dotty.tools.dotc.transform.sjs.JSSymUtils._
-
-import dotty.tools.sjs.ir
-import dotty.tools.sjs.ir.{Trees => js, Types => jstpe}
-import dotty.tools.sjs.ir.Names.{LocalName, LabelName, FieldName, SimpleMethodName, MethodName, ClassName}
-import dotty.tools.sjs.ir.OriginalName
-import dotty.tools.sjs.ir.OriginalName.NoOriginalName
-import dotty.tools.sjs.ir.UTF8String
-
-import dotty.tools.backend.jvm.DottyBackendInterface.symExtensions
-
-import JSDefinitions.jsdefn
-
-/** Encoding of symbol names for JavaScript
- *
- *  Some issues that this encoding solves:
- *  * Overloading: encode the full signature in the JS name
- *  * Same scope for fields and methods of a class
- *  * Global access to classes and modules (by their full name)
- *
- *  @author Sébastien Doeraene
- */
-object JSEncoding {
-
-  /** Name of the capture param storing the JS super class.
-   *
-   *  This is used by the dispatchers of exposed JS methods and properties of
-   *  nested JS classes when they need to perform a super call. Other super
-   *  calls (in the actual bodies of the methods, not in the dispatchers) do
-   *  not use this value, since they are implemented as static methods that do
-   *  not have access to it. Instead, they get the JS super class value through
-   *  the magic method inserted by `ExplicitLocalJS`, leveraging `lambdalift`
-   *  to ensure that it is properly captured.
-   *
-   *  Using this identifier is only allowed if it was reserved in the current
-   *  local name scope using [[reserveLocalName]]. Otherwise, this name can
-   *  clash with another local identifier.
-   */
-  final val JSSuperClassParamName = LocalName("superClass$")
-
-  private val ScalaRuntimeNothingClassName = ClassName("scala.runtime.Nothing$")
-  private val ScalaRuntimeNullClassName = ClassName("scala.runtime.Null$")
-
-  private val dynamicImportForwarderSimpleName = SimpleMethodName("dynamicImport$")
-
-  // Fresh local name generator ----------------------------------------------
-
-  class LocalNameGenerator {
-    import LocalNameGenerator._
-
-    private val usedLocalNames = mutable.Set.empty[LocalName]
-    private val localSymbolNames = mutable.Map.empty[Symbol, LocalName]
-    private val usedLabelNames = mutable.Set.empty[LabelName]
-    private val labelSymbolNames = mutable.Map.empty[Symbol, LabelName]
-    private var returnLabelName: Option[LabelName] = None
-
-    def reserveLocalName(name: LocalName): Unit = {
-      require(usedLocalNames.isEmpty,
-          s"Trying to reserve the name '$name' but names have already been allocated")
-      usedLocalNames += name
-    }
-
-    private def freshNameGeneric[N <: ir.Names.Name](base: N, usedNamesSet: mutable.Set[N])(
-        withSuffix: (N, String) => N): N = {
-
-      var suffix = 1
-      var result = base
-      while (usedNamesSet(result)) {
-        suffix += 1
-        result = withSuffix(base, "$" + suffix)
-      }
-      usedNamesSet += result
-      result
-    }
-
-    def freshName(base: LocalName): LocalName =
-      freshNameGeneric(base, usedLocalNames)(_.withSuffix(_))
-
-    def freshName(base: String): LocalName =
-      freshName(LocalName(base))
-
-    def freshLocalIdent()(implicit pos: ir.Position): js.LocalIdent =
-      js.LocalIdent(freshName(xLocalName))
-
-    def freshLocalIdent(base: LocalName)(implicit pos: ir.Position): js.LocalIdent =
-      js.LocalIdent(freshName(base))
-
-    def freshLocalIdent(base: String)(implicit pos: ir.Position): js.LocalIdent =
-      freshLocalIdent(LocalName(base))
-
-    def freshLocalIdent(base: TermName)(implicit pos: ir.Position): js.LocalIdent =
-      freshLocalIdent(base.mangledString)
-
-    def localSymbolName(sym: Symbol)(using Context): LocalName = {
-      localSymbolNames.getOrElseUpdate(sym, {
-        /* The emitter does not like local variables that start with a '$',
-         * because it needs to encode them not to clash with emitter-generated
-         * names. There are two common cases, caused by scalac-generated names:
-         * - the `$this` parameter of tailrec methods and "extension" methods of
-         *   AnyVals, which scalac knows as `nme.SELF`, and
-         * - the `$outer` parameter of inner class constructors, which scalac
-         *   knows as `nme.OUTER`.
-         * We choose different base names for those two cases instead, so that
-         * the avoidance mechanism of the emitter doesn't happen as a common
-         * case. It can still happen for user-defined variables, but in that case
-         * the emitter will deal with it.
-         */
-        val base = sym.name match {
-          case nme.SELF  => "this$" // instead of $this
-          case nme.OUTER => "outer" // instead of $outer
-          case name      => name.mangledString
-        }
-        freshName(base)
-      })
-    }
-
-    def freshLabelName(base: LabelName): LabelName =
-      freshNameGeneric(base, usedLabelNames)(_.withSuffix(_))
-
-    def freshLabelName(base: String): LabelName =
-      freshLabelName(LabelName(base))
-
-    def freshLabelIdent(base: String)(implicit pos: ir.Position): js.LabelIdent =
-      js.LabelIdent(freshLabelName(base))
-
-    def labelSymbolName(sym: Symbol)(using Context): LabelName =
-      labelSymbolNames.getOrElseUpdate(sym, freshLabelName(sym.javaSimpleName))
-
-    def getEnclosingReturnLabel()(implicit pos: ir.Position): js.LabelIdent = {
-      if (returnLabelName.isEmpty)
-        returnLabelName = Some(freshLabelName("_return"))
-      js.LabelIdent(returnLabelName.get)
-    }
-
-    /* If this `LocalNameGenerator` has a `returnLabelName` (often added in the
-     * construction of the `body` argument), wrap the resulting js.Tree to use that label.
-     */
-    def makeLabeledIfRequiresEnclosingReturn(tpe: jstpe.Type)(body: js.Tree)(implicit pos: ir.Position): js.Tree = {
-      returnLabelName match {
-        case None =>
-          body
-        case Some(labelName) =>
-          js.Labeled(js.LabelIdent(labelName), tpe, body)
-      }
-    }
-  }
-
-  private object LocalNameGenerator {
-    private val xLocalName = LocalName("x")
-  }
-
-  // Encoding methods ----------------------------------------------------------
-
-  def encodeLabelSym(sym: Symbol)(
-      implicit ctx: Context, pos: ir.Position, localNames: LocalNameGenerator): js.LabelIdent = {
-    require(sym.is(Flags.Label), "encodeLabelSym called with non-label symbol: " + sym)
-    js.LabelIdent(localNames.labelSymbolName(sym))
-  }
-
-  def encodeFieldSym(sym: Symbol)(implicit ctx: Context, pos: ir.Position): js.FieldIdent =
-    js.FieldIdent(FieldName(encodeFieldSymAsString(sym)))
-
-  def encodeFieldSymAsStringLiteral(sym: Symbol)(implicit ctx: Context, pos: ir.Position): js.StringLiteral =
-    js.StringLiteral(encodeFieldSymAsString(sym))
-
-  private def encodeFieldSymAsString(sym: Symbol)(using Context): String = {
-    require(sym.owner.isClass && sym.isTerm && !sym.isOneOf(MethodOrModule),
-        "encodeFieldSym called with non-field symbol: " + sym)
-
-    val name0 = sym.javaSimpleName
-    if (name0.charAt(name0.length() - 1) != ' ') name0
-    else name0.substring(0, name0.length() - 1)
-  }
-
-  def encodeMethodSym(sym: Symbol, reflProxy: Boolean = false)(
-      implicit ctx: Context, pos: ir.Position): js.MethodIdent = {
-    require(sym.is(Flags.Method), "encodeMethodSym called with non-method symbol: " + sym)
-
-    val tpe = sym.info
-
-    val paramTypeRefs0 = tpe.firstParamTypes.map(paramOrResultTypeRef(_))
-
-    val hasExplicitThisParameter = !sym.is(JavaStatic) && sym.owner.isNonNativeJSClass
-    val paramTypeRefs =
-      if (!hasExplicitThisParameter) paramTypeRefs0
-      else encodeClassRef(sym.owner) :: paramTypeRefs0
-
-    val name = sym.name
-    val simpleName = SimpleMethodName(name.mangledString)
-
-    val methodName = {
-      if (sym.isClassConstructor)
-        MethodName.constructor(paramTypeRefs)
-      else if (reflProxy)
-        MethodName.reflectiveProxy(simpleName, paramTypeRefs)
-      else
-        MethodName(simpleName, paramTypeRefs, paramOrResultTypeRef(patchedResultType(sym)))
-    }
-
-    js.MethodIdent(methodName)
-  }
-
-  def encodeJSNativeMemberSym(sym: Symbol)(using Context, ir.Position): js.MethodIdent = {
-    require(sym.hasAnnotation(jsdefn.JSNativeAnnot),
-        "encodeJSNativeMemberSym called with non-native symbol: " + sym)
-    if (sym.is(Method))
-      encodeMethodSym(sym)
-    else
-      encodeFieldSymAsMethod(sym)
-  }
-
-  def encodeStaticMemberSym(sym: Symbol)(using Context, ir.Position): js.MethodIdent = {
-    require(sym.is(Flags.JavaStaticTerm),
-        "encodeStaticMemberSym called with non-static symbol: " + sym)
-    encodeFieldSymAsMethod(sym)
-  }
-
-  private def encodeFieldSymAsMethod(sym: Symbol)(using Context, ir.Position): js.MethodIdent = {
-    val name = sym.name
-    val resultTypeRef = paramOrResultTypeRef(sym.info)
-    val methodName = MethodName(name.mangledString, Nil, resultTypeRef)
-    js.MethodIdent(methodName)
-  }
-
-  def encodeDynamicImportForwarderIdent(params: List[Symbol])(using Context, ir.Position): js.MethodIdent = {
-    val paramTypeRefs = params.map(sym => paramOrResultTypeRef(sym.info))
-    val resultTypeRef = jstpe.ClassRef(ir.Names.ObjectClass)
-    val methodName = MethodName(dynamicImportForwarderSimpleName, paramTypeRefs, resultTypeRef)
-    js.MethodIdent(methodName)
-  }
-
-  /** Computes the type ref for a type, to be used in a method signature. */
-  private def paramOrResultTypeRef(tpe: Type)(using Context): jstpe.TypeRef =
-    toParamOrResultTypeRef(toTypeRef(tpe))
-
-  def encodeLocalSym(sym: Symbol)(
-      implicit ctx: Context, pos: ir.Position, localNames: LocalNameGenerator): js.LocalIdent = {
-    require(!sym.owner.isClass && sym.isTerm && !sym.is(Flags.Method) && !sym.is(Flags.Module),
-        "encodeLocalSym called with non-local symbol: " + sym)
-    js.LocalIdent(localNames.localSymbolName(sym))
-  }
-
-  def encodeClassType(sym: Symbol)(using Context): jstpe.Type = {
-    if (sym == defn.ObjectClass) jstpe.AnyType
-    else if (sym.isJSType) jstpe.AnyType
-    else {
-      assert(sym != defn.ArrayClass,
-          "encodeClassType() cannot be called with ArrayClass")
-      jstpe.ClassType(encodeClassName(sym))
-    }
-  }
-
-  def encodeClassRef(sym: Symbol)(using Context): jstpe.ClassRef =
-    jstpe.ClassRef(encodeClassName(sym))
-
-  def encodeClassNameIdent(sym: Symbol)(
-      implicit ctx: Context, pos: ir.Position): js.ClassIdent =
-    js.ClassIdent(encodeClassName(sym))
-
-  def encodeClassName(sym: Symbol)(using Context): ClassName = {
-    val sym1 =
-      if (sym.isAllOf(ModuleClass | JavaDefined)) sym.linkedClass
-      else sym
-
-    /* Some rewirings:
-     * - scala.runtime.BoxedUnit to java.lang.Void, as the IR expects.
-     *   BoxedUnit$ is a JVM artifact.
-     * - scala.Nothing to scala.runtime.Nothing$.
-     * - scala.Null to scala.runtime.Null$.
-     */
-    if (sym1 == defn.BoxedUnitClass)
-      ir.Names.BoxedUnitClass
-    else if (sym1 == defn.NothingClass)
-      ScalaRuntimeNothingClassName
-    else if (sym1 == defn.NullClass)
-      ScalaRuntimeNullClassName
-    else
-      ClassName(sym1.javaClassName)
-  }
-
-  /** Converts a general TypeRef to a TypeRef to be used in a method signature. */
-  def toParamOrResultTypeRef(typeRef: jstpe.TypeRef): jstpe.TypeRef = {
-    typeRef match {
-      case jstpe.ClassRef(ScalaRuntimeNullClassName)    => jstpe.NullRef
-      case jstpe.ClassRef(ScalaRuntimeNothingClassName) => jstpe.NothingRef
-      case _                                            => typeRef
-    }
-  }
-
-  def toIRTypeAndTypeRef(tp: Type)(using Context): (jstpe.Type, jstpe.TypeRef) = {
-    val typeRefInternal = toTypeRefInternal(tp)
-    (toIRTypeInternal(typeRefInternal), typeRefInternal._1)
-  }
-
-  def toIRType(tp: Type)(using Context): jstpe.Type =
-    toIRTypeInternal(toTypeRefInternal(tp))
-
-  private def toIRTypeInternal(typeRefInternal: (jstpe.TypeRef, Symbol))(using Context): jstpe.Type = {
-    typeRefInternal._1 match {
-      case jstpe.PrimRef(irTpe) =>
-        irTpe
-
-      case typeRef: jstpe.ClassRef =>
-        val sym = typeRefInternal._2
-        if (sym == defn.ObjectClass || sym.isJSType)
-          jstpe.AnyType
-        else if (sym == defn.NothingClass)
-          jstpe.NothingType
-        else if (sym == defn.NullClass)
-          jstpe.NullType
-        else
-          jstpe.ClassType(typeRef.className)
-
-      case typeRef: jstpe.ArrayTypeRef =>
-        jstpe.ArrayType(typeRef)
-    }
-  }
-
-  def toTypeRef(tp: Type)(using Context): jstpe.TypeRef =
-    toTypeRefInternal(tp)._1
-
-  private def toTypeRefInternal(tp: Type)(using Context): (jstpe.TypeRef, Symbol) = {
-    def primitiveOrClassToTypeRef(sym: Symbol): (jstpe.TypeRef, Symbol) = {
-      assert(sym.isClass, sym)
-      //assert(sym != defn.ArrayClass || isCompilingArray, sym)
-      val typeRef = if (sym.isPrimitiveValueClass) {
-        if (sym == defn.UnitClass) jstpe.VoidRef
-        else if (sym == defn.BooleanClass) jstpe.BooleanRef
-        else if (sym == defn.CharClass) jstpe.CharRef
-        else if (sym == defn.ByteClass) jstpe.ByteRef
-        else if (sym == defn.ShortClass) jstpe.ShortRef
-        else if (sym == defn.IntClass) jstpe.IntRef
-        else if (sym == defn.LongClass) jstpe.LongRef
-        else if (sym == defn.FloatClass) jstpe.FloatRef
-        else if (sym == defn.DoubleClass) jstpe.DoubleRef
-        else throw new Exception(s"unknown primitive value class $sym")
-      } else {
-        encodeClassRef(sym)
-      }
-      (typeRef, sym)
-    }
-
-    /**
-     * When compiling Array.scala, the type parameter T is not erased and shows up in method
-     * signatures, e.g. `def apply(i: Int): T`. A TyperRef to T is replaced by ObjectReference.
-     */
-    def nonClassTypeRefToTypeRef(sym: Symbol): (jstpe.TypeRef, Symbol) = {
-      //assert(sym.isType && isCompilingArray, sym)
-      (jstpe.ClassRef(ir.Names.ObjectClass), defn.ObjectClass)
-    }
-
-    tp.widenDealias match {
-      // Array type such as Array[Int] (kept by erasure)
-      case JavaArrayType(el) =>
-        val elTypeRef = toTypeRefInternal(el)
-        (jstpe.ArrayTypeRef.of(elTypeRef._1), elTypeRef._2)
-
-      case t: TypeRef =>
-        if (!t.symbol.isClass) nonClassTypeRefToTypeRef(t.symbol)  // See comment on nonClassTypeRefToBType
-        else primitiveOrClassToTypeRef(t.symbol) // Common reference to a type such as scala.Int or java.lang.String
-
-      case Types.ClassInfo(_, sym, _, _, _) =>
-        /* We get here, for example, for genLoadModule, which invokes
-         * toTypeKind(moduleClassSymbol.info)
-         */
-        primitiveOrClassToTypeRef(sym)
-
-      /* AnnotatedType should (probably) be eliminated by erasure. However we know it happens for
-       * meta-annotated annotations (@(ann @getter) val x = 0), so we don't emit a warning.
-       * The type in the AnnotationInfo is an AnnotatedTpe. Tested in jvm/annotations.scala.
-       */
-      case a @ AnnotatedType(t, _) =>
-        //debuglog(s"typeKind of annotated type $a")
-        toTypeRefInternal(t)
-    }
-  }
-
-  /** Patches the result type of a method symbol to sanitize it.
-   *
-   *  For some reason, dotc thinks that the `info.resultType`of an
-   *  `isConstructor` method (for classes or traits) is the enclosing class
-   *  or trait, but the bodies and usages act as if the result type was `Unit`.
-   *
-   *  This method returns `UnitType` for constructor methods, and otherwise
-   *  `sym.info.resultType`.
-   */
-  def patchedResultType(sym: Symbol)(using Context): Type =
-    if (sym.isConstructor) defn.UnitType
-    else sym.info.resultType
-
-  def originalNameOfLocal(sym: Symbol)(
-      implicit ctx: Context, localNames: LocalNameGenerator): OriginalName = {
-    val irName = localNames.localSymbolName(sym)
-    val originalName = UTF8String(sym.name.unexpandedName.toString)
-    if (UTF8String.equals(originalName, irName.encoded)) NoOriginalName
-    else OriginalName(originalName)
-  }
-
-  def originalNameOfField(sym: Symbol)(using Context): OriginalName =
-    originalNameOf(sym.name)
-
-  def originalNameOfMethod(sym: Symbol)(using Context): OriginalName =
-    originalNameOf(sym.name)
-
-  def originalNameOfClass(sym: Symbol)(using Context): OriginalName =
-    originalNameOf(sym.fullName)
-
-  private def originalNameOf(name: Name): OriginalName = {
-    val originalName = name.unexpandedName.toString
-    if (originalName == name.mangledString) NoOriginalName
-    else OriginalName(originalName)
-  }
-}
diff --git a/tests/pos-with-compiler-cc/backend/sjs/JSExportsGen.scala b/tests/pos-with-compiler-cc/backend/sjs/JSExportsGen.scala
deleted file mode 100644
index 82b69e6a16a7..000000000000
--- a/tests/pos-with-compiler-cc/backend/sjs/JSExportsGen.scala
+++ /dev/null
@@ -1,1025 +0,0 @@
-package dotty.tools.backend.sjs
-
-import scala.language.unsafeNulls
-
-import scala.annotation.tailrec
-import scala.collection.mutable
-
-import dotty.tools.dotc.core._
-
-import Contexts._
-import Decorators._
-import Denotations._
-import Flags._
-import Names._
-import NameKinds.DefaultGetterName
-import NameOps._
-import Phases._
-import Symbols._
-import Types._
-import TypeErasure.ErasedValueType
-
-import dotty.tools.dotc.util.{SourcePosition, SrcPos}
-import dotty.tools.dotc.report
-
-import dotty.tools.sjs.ir.{Position, Names => jsNames, Trees => js, Types => jstpe}
-import dotty.tools.sjs.ir.Names.DefaultModuleID
-import dotty.tools.sjs.ir.OriginalName.NoOriginalName
-import dotty.tools.sjs.ir.Position.NoPosition
-import dotty.tools.sjs.ir.Trees.OptimizerHints
-
-import dotty.tools.dotc.transform.sjs.JSExportUtils._
-import dotty.tools.dotc.transform.sjs.JSSymUtils._
-
-import JSEncoding._
-
-final class JSExportsGen(jsCodeGen: JSCodeGen)(using Context) {
-  import jsCodeGen._
-  import positionConversions._
-
-  /** Info for a non-member export. */
-  sealed trait ExportInfo {
-    val pos: SourcePosition
-  }
-
-  final case class TopLevelExportInfo(moduleID: String, jsName: String)(val pos: SourcePosition) extends ExportInfo
-  final case class StaticExportInfo(jsName: String)(val pos: SourcePosition) extends ExportInfo
-
-  private sealed trait ExportKind
-
-  private object ExportKind {
-    case object Module extends ExportKind
-    case object JSClass extends ExportKind
-    case object Constructor extends ExportKind
-    case object Method extends ExportKind
-    case object Property extends ExportKind
-    case object Field extends ExportKind
-
-    def apply(sym: Symbol): ExportKind = {
-      if (sym.is(Flags.Module) && sym.isStatic) Module
-      else if (sym.isClass) JSClass
-      else if (sym.isConstructor) Constructor
-      else if (!sym.is(Flags.Method)) Field
-      else if (sym.isJSProperty) Property
-      else Method
-    }
-  }
-
-  private def topLevelExportsOf(sym: Symbol): List[TopLevelExportInfo] = {
-    def isScalaClass(sym: Symbol): Boolean =
-      sym.isClass && !sym.isOneOf(Module | Trait) && !sym.isJSType
-
-    if (isScalaClass(sym)) {
-      // Scala classes are never exported; their constructors are
-      Nil
-    } else if (sym.is(Accessor) || sym.is(Module, butNot = ModuleClass)) {
-      /* - Accessors receive the `@JSExportTopLevel` annotation of their associated field,
-       *   but only the field is really exported.
-       * - Module values are not exported; their module class takes care of the export.
-       */
-      Nil
-    } else {
-      val symForAnnot =
-        if (sym.isConstructor && isScalaClass(sym.owner)) sym.owner
-        else sym
-
-      symForAnnot.annotations.collect {
-        case annot if annot.symbol == jsdefn.JSExportTopLevelAnnot =>
-          val jsName = annot.argumentConstantString(0).get
-          val moduleID = annot.argumentConstantString(1).getOrElse(DefaultModuleID)
-          TopLevelExportInfo(moduleID, jsName)(annot.tree.sourcePos)
-      }
-    }
-  }
-
-  private def staticExportsOf(sym: Symbol): List[StaticExportInfo] = {
-    if (sym.is(Accessor)) {
-      Nil
-    } else {
-      sym.annotations.collect {
-        case annot if annot.symbol == jsdefn.JSExportStaticAnnot =>
-          val jsName = annot.argumentConstantString(0).getOrElse {
-            sym.defaultJSName
-          }
-          StaticExportInfo(jsName)(annot.tree.sourcePos)
-      }
-    }
-  }
-
-  private def checkSameKind(tups: List[(ExportInfo, Symbol)]): Option[ExportKind] = {
-    assert(tups.nonEmpty, "must have at least one export")
-
-    val firstSym = tups.head._2
-    val overallKind = ExportKind(firstSym)
-    var bad = false
-
-    for ((info, sym) <- tups.tail) {
-      val kind = ExportKind(sym)
-
-      if (kind != overallKind) {
-        bad = true
-        report.error(
-            em"export overload conflicts with export of $firstSym: they are of different types (${kind.tryToShow} / ${overallKind.tryToShow})",
-            info.pos)
-      }
-    }
-
-    if (bad) None
-    else Some(overallKind)
-  }
-
-  private def checkSingleField(tups: List[(ExportInfo, Symbol)]): Symbol = {
-    assert(tups.nonEmpty, "must have at least one export")
-
-    val firstSym = tups.head._2
-
-    for ((info, _) <- tups.tail) {
-      report.error(
-          em"export overload conflicts with export of $firstSym: a field may not share its exported name with another export",
-          info.pos)
-    }
-
-    firstSym
-  }
-
-  def genTopLevelExports(classSym: ClassSymbol): List[js.TopLevelExportDef] = {
-    val exports = for {
-      sym <- classSym :: classSym.info.decls.toList
-      info <- topLevelExportsOf(sym)
-    } yield {
-      (info, sym)
-    }
-
-    (for {
-      (info, tups) <- exports.groupBy(_._1)
-      kind <- checkSameKind(tups)
-    } yield {
-      import ExportKind._
-
-      implicit val pos = info.pos
-
-      kind match {
-        case Module =>
-          js.TopLevelModuleExportDef(info.moduleID, info.jsName)
-
-        case JSClass =>
-          assert(classSym.isNonNativeJSClass, "found export on non-JS class")
-          js.TopLevelJSClassExportDef(info.moduleID, info.jsName)
-
-        case Constructor | Method =>
-          val exported = tups.map(_._2)
-
-          val methodDef = withNewLocalNameScope {
-            genExportMethod(exported, JSName.Literal(info.jsName), static = true)
-          }
-
-          js.TopLevelMethodExportDef(info.moduleID, methodDef)
-
-        case Property =>
-          throw new AssertionError("found top-level exported property")
-
-        case Field =>
-          val sym = checkSingleField(tups)
-          js.TopLevelFieldExportDef(info.moduleID, info.jsName, encodeFieldSym(sym))
-      }
-    }).toList
-  }
-
-  def genStaticExports(classSym: Symbol): List[js.MemberDef] = {
-    val exports = for {
-      sym <- classSym.info.decls.toList
-      info <- staticExportsOf(sym)
-    } yield {
-      (info, sym)
-    }
-
-    (for {
-      (info, tups) <- exports.groupBy(_._1)
-      kind <- checkSameKind(tups)
-    } yield {
-      def alts = tups.map(_._2)
-
-      implicit val pos = info.pos
-
-      import ExportKind._
-
-      kind match {
-        case Method =>
-          genMemberExportOrDispatcher(JSName.Literal(info.jsName), isProp = false, alts, static = true)
-
-        case Property =>
-          genMemberExportOrDispatcher(JSName.Literal(info.jsName), isProp = true, alts, static = true)
-
-        case Field =>
-          val sym = checkSingleField(tups)
-
-          // static fields must always be mutable
-          val flags = js.MemberFlags.empty
-            .withNamespace(js.MemberNamespace.PublicStatic)
-            .withMutable(true)
-          val name = js.StringLiteral(info.jsName)
-          val irTpe = genExposedFieldIRType(sym)
-          js.JSFieldDef(flags, name, irTpe)
-
-        case kind =>
-          throw new AssertionError(s"unexpected static export kind: $kind")
-      }
-    }).toList
-  }
-
-  /** Generates exported methods and properties for a class.
-   *
-   *  @param classSym symbol of the class we export for
-   */
-  def genMemberExports(classSym: ClassSymbol): List[js.MemberDef] = {
-    val classInfo = classSym.info
-    val allExports = classInfo.memberDenots(takeAllFilter, { (name, buf) =>
-      if (isExportName(name))
-        buf ++= classInfo.member(name).alternatives
-    })
-
-    val newlyDeclaredExports = if (classSym.superClass == NoSymbol) {
-      allExports
-    } else {
-      allExports.filterNot { denot =>
-        classSym.superClass.info.member(denot.name).hasAltWith(_.info =:= denot.info)
-      }
-    }
-
-    val newlyDeclaredExportNames = newlyDeclaredExports.map(_.name.toTermName).toList.distinct
-
-    newlyDeclaredExportNames.map(genMemberExport(classSym, _))
-  }
-
-  private def genMemberExport(classSym: ClassSymbol, name: TermName): js.MemberDef = {
-    /* This used to be `.member(name)`, but it caused #3538, since we were
-     * sometimes selecting mixin forwarders, whose type history does not go
-     * far enough back in time to see varargs. We now explicitly exclude
-     * mixed-in members in addition to bridge methods (the latter are always
-     * excluded by `.member(name)`).
-     */
-    val alts = classSym
-      .findMemberNoShadowingBasedOnFlags(name, classSym.appliedRef, required = Method, excluded = Bridge | MixedIn)
-      .alternatives
-
-    assert(!alts.isEmpty,
-        em"""Ended up with no alternatives for ${classSym.fullName}::$name.
-            |Original set was ${alts} with types ${alts.map(_.info)}""")
-
-    val (jsName, isProp) = exportNameInfo(name)
-
-    // Check if we have a conflicting export of the other kind
-    val conflicting = classSym.info.member(makeExportName(jsName, !isProp))
-
-    if (conflicting.exists) {
-      val kind = if (isProp) "property" else "method"
-      val conflictingMember = conflicting.alternatives.head.symbol.fullName
-      val errorPos: SrcPos = alts.map(_.symbol).filter(_.owner == classSym) match {
-        case Nil         => classSym
-        case altsInClass => altsInClass.minBy(_.span.point)
-      }
-      report.error(em"Exported $kind $jsName conflicts with $conflictingMember", errorPos)
-    }
-
-    genMemberExportOrDispatcher(JSName.Literal(jsName), isProp, alts.map(_.symbol), static = false)
-  }
-
-  def genJSClassDispatchers(classSym: Symbol, dispatchMethodsNames: List[JSName]): List[js.MemberDef] = {
-    dispatchMethodsNames.map(genJSClassDispatcher(classSym, _))
-  }
-
-  private def genJSClassDispatcher(classSym: Symbol, name: JSName): js.MemberDef = {
-    val alts = classSym.info.membersBasedOnFlags(required = Method, excluded = Bridge)
-      .map(_.symbol)
-      .filter { sym =>
-        /* scala-js#3939: Object is not a "real" superclass of JS types.
-         * as such, its methods do not participate in overload resolution.
-         * An exception is toString, which is handled specially in genExportMethod.
-         */
-        sym.owner != defn.ObjectClass && sym.jsName == name
-      }
-      .toList
-
-    assert(!alts.isEmpty, s"Ended up with no alternatives for ${classSym.fullName}::$name.")
-
-    val (propSyms, methodSyms) = alts.partition(_.isJSProperty)
-    val isProp = propSyms.nonEmpty
-
-    if (isProp && methodSyms.nonEmpty) {
-      val firstAlt = alts.head
-      report.error(
-          em"Conflicting properties and methods for ${classSym.fullName}::$name.",
-          firstAlt.srcPos)
-      implicit val pos = firstAlt.span
-      js.JSPropertyDef(js.MemberFlags.empty, genExpr(name)(firstAlt.sourcePos), None, None)
-    } else {
-      genMemberExportOrDispatcher(name, isProp, alts, static = false)
-    }
-  }
-
-  private def genMemberExportOrDispatcher(jsName: JSName, isProp: Boolean,
-      alts: List[Symbol], static: Boolean): js.MemberDef = {
-    withNewLocalNameScope {
-      if (isProp)
-        genExportProperty(alts, jsName, static)
-      else
-        genExportMethod(alts, jsName, static)
-    }
-  }
-
-  private def genExportProperty(alts: List[Symbol], jsName: JSName, static: Boolean): js.JSPropertyDef = {
-    assert(!alts.isEmpty, s"genExportProperty with empty alternatives for $jsName")
-
-    implicit val pos: Position = alts.head.span
-
-    val namespace =
-      if (static) js.MemberNamespace.PublicStatic
-      else js.MemberNamespace.Public
-    val flags = js.MemberFlags.empty.withNamespace(namespace)
-
-    /* Separate getters and setters. Since we only have getters and setters, we
-     * simply test the param list size, which is faster than using the full isJSGetter.
-     */
-    val (getter, setters) = alts.partition(_.info.paramInfoss.head.isEmpty)
-
-    // We can have at most one getter
-    if (getter.sizeIs > 1)
-      reportCannotDisambiguateError(jsName, alts)
-
-    val getterBody = getter.headOption.map { getterSym =>
-      genApplyForSingleExported(new FormalArgsRegistry(0, false), new ExportedSymbol(getterSym, static), static)
-    }
-
-    val setterArgAndBody = {
-      if (setters.isEmpty) {
-        None
-      } else {
-        val formalArgsRegistry = new FormalArgsRegistry(1, false)
-        val (List(arg), None) = formalArgsRegistry.genFormalArgs(): @unchecked
-        val body = genOverloadDispatchSameArgc(jsName, formalArgsRegistry,
-            setters.map(new ExportedSymbol(_, static)), jstpe.AnyType, None)
-        Some((arg, body))
-      }
-    }
-
-    js.JSPropertyDef(flags, genExpr(jsName)(alts.head.sourcePos), getterBody, setterArgAndBody)
-  }
-
-  private def genExportMethod(alts0: List[Symbol], jsName: JSName, static: Boolean)(using Context): js.JSMethodDef = {
-    assert(alts0.nonEmpty, "need at least one alternative to generate exporter method")
-
-    implicit val pos: SourcePosition = alts0.head.sourcePos
-
-    val namespace =
-      if (static) js.MemberNamespace.PublicStatic
-      else js.MemberNamespace.Public
-    val flags = js.MemberFlags.empty.withNamespace(namespace)
-
-    // toString() is always exported. We might need to add it here to get correct overloading.
-    val alts = jsName match {
-      case JSName.Literal("toString") if alts0.forall(_.info.paramInfoss.exists(_.nonEmpty)) =>
-        defn.Any_toString :: alts0
-      case _ =>
-        alts0
-    }
-
-    val overloads = alts.map(new ExportedSymbol(_, static))
-
-    val (formalArgs, restParam, body) =
-      genOverloadDispatch(jsName, overloads, jstpe.AnyType)
-
-    js.JSMethodDef(flags, genExpr(jsName), formalArgs, restParam, body)(
-        OptimizerHints.empty, None)
-  }
-
-  def genOverloadDispatch(jsName: JSName, alts: List[Exported], tpe: jstpe.Type)(
-      using pos: SourcePosition): (List[js.ParamDef], Option[js.ParamDef], js.Tree) = {
-
-    // Create the formal args registry
-    val hasVarArg = alts.exists(_.hasRepeatedParam)
-    val minArgc = alts.map(_.minArgc).min
-    val maxNonRepeatedArgc = alts.map(_.maxNonRepeatedArgc).max
-    val needsRestParam = maxNonRepeatedArgc != minArgc || hasVarArg
-    val formalArgsRegistry = new FormalArgsRegistry(minArgc, needsRestParam)
-
-    // Generate the list of formal parameters
-    val (formalArgs, restParam) = formalArgsRegistry.genFormalArgs()
-
-    /* Generate the body
-     * We have a fast-path for methods that are not overloaded. In addition to
-     * being a fast path, it does a better job than `genExportMethodMultiAlts`
-     * when the only alternative has default parameters, because it avoids a
-     * spurious dispatch.
-     * In scalac, the spurious dispatch was avoided by a more elaborate case
-     * generation in `genExportMethod`, which was very convoluted and was not
-     * ported to dotc.
-     */
-    val body =
-      if (alts.tail.isEmpty) alts.head.genBody(formalArgsRegistry)
-      else genExportMethodMultiAlts(formalArgsRegistry, maxNonRepeatedArgc, alts, tpe, jsName)
-
-    (formalArgs, restParam, body)
-  }
-
-  private def genExportMethodMultiAlts(formalArgsRegistry: FormalArgsRegistry,
-      maxNonRepeatedArgc: Int, alts: List[Exported], tpe: jstpe.Type, jsName: JSName)(
-      implicit pos: SourcePosition): js.Tree = {
-
-    // Generate tuples (argc, method)
-    val methodArgCounts = for {
-      alt <- alts
-      argc <- alt.minArgc to (if (alt.hasRepeatedParam) maxNonRepeatedArgc else alt.maxNonRepeatedArgc)
-    } yield {
-      (argc, alt)
-    }
-
-    // Create a list of (argCount -> methods), sorted by argCount (methods may appear multiple times)
-    val methodsByArgCount: List[(Int, List[Exported])] =
-      methodArgCounts.groupMap(_._1)(_._2).toList.sortBy(_._1) // sort for determinism
-
-    val altsWithVarArgs = alts.filter(_.hasRepeatedParam)
-
-    // Generate a case block for each (argCount, methods) tuple
-    // TODO? We could optimize this a bit by putting together all the `argCount`s that have the same methods
-    // (Scala.js for scalac does that, but the code is very convoluted and it's not clear that it is worth it).
-    val cases = for {
-      (argc, methods) <- methodsByArgCount
-      if methods != altsWithVarArgs // exclude default case we're generating anyways for varargs
-    } yield {
-      // body of case to disambiguates methods with current count
-      val caseBody = genOverloadDispatchSameArgc(jsName, formalArgsRegistry, methods, tpe, Some(argc))
-      List(js.IntLiteral(argc - formalArgsRegistry.minArgc)) -> caseBody
-    }
-
-    def defaultCase = {
-      if (altsWithVarArgs.isEmpty)
-        genThrowTypeError()
-      else
-        genOverloadDispatchSameArgc(jsName, formalArgsRegistry, altsWithVarArgs, tpe, None)
-    }
-
-    val body = {
-      if (cases.isEmpty) {
-        defaultCase
-      } else if (cases.tail.isEmpty && altsWithVarArgs.isEmpty) {
-        cases.head._2
-      } else {
-        val restArgRef = formalArgsRegistry.genRestArgRef()
-        js.Match(
-            js.AsInstanceOf(js.JSSelect(restArgRef, js.StringLiteral("length")), jstpe.IntType),
-            cases,
-            defaultCase)(
-            tpe)
-      }
-    }
-
-    body
-  }
-
-  /** Resolves method calls to [[alts]] while assuming they have the same parameter count.
-   *
-   *  @param jsName
-   *    The JS name of the method, for error reporting
-   *  @param formalArgsRegistry
-   *    The registry of all the formal arguments
-   *  @param alts
-   *    Alternative methods
-   *  @param tpe
-   *    Result type
-   *  @param maxArgc
-   *    Maximum number of arguments to use for disambiguation
-   */
-  private def genOverloadDispatchSameArgc(jsName: JSName, formalArgsRegistry: FormalArgsRegistry,
-      alts: List[Exported], tpe: jstpe.Type, maxArgc: Option[Int]): js.Tree = {
-    genOverloadDispatchSameArgcRec(jsName, formalArgsRegistry, alts, tpe, paramIndex = 0, maxArgc)
-  }
-
-  /** Resolves method calls to [[alts]] while assuming they have the same parameter count.
-   *
-   *  @param jsName
-   *    The JS name of the method, for error reporting
-   *  @param formalArgsRegistry
-   *    The registry of all the formal arguments
-   *  @param alts
-   *    Alternative methods
-   *  @param tpe
-   *    Result type
-   *  @param paramIndex
-   *    Index where to start disambiguation (starts at 0, increases through recursion)
-   *  @param maxArgc
-   *    Maximum number of arguments to use for disambiguation
-   */
-  private def genOverloadDispatchSameArgcRec(jsName: JSName, formalArgsRegistry: FormalArgsRegistry,
-      alts: List[Exported], tpe: jstpe.Type, paramIndex: Int, maxArgc: Option[Int]): js.Tree = {
-
-    implicit val pos = alts.head.pos
-
-    if (alts.sizeIs == 1) {
-      alts.head.genBody(formalArgsRegistry)
-    } else if (maxArgc.exists(_ <= paramIndex) || !alts.exists(_.params.size > paramIndex)) {
-      // We reach here in three cases:
-      // 1. The parameter list has been exhausted
-      // 2. The optional argument count restriction has triggered
-      // 3. We only have (more than once) repeated parameters left
-      // Therefore, we should fail
-      reportCannotDisambiguateError(jsName, alts.map(_.sym))
-      js.Undefined()
-    } else {
-      val altsByTypeTest = groupByWithoutHashCode(alts) { exported =>
-        typeTestForTpe(exported.exportArgTypeAt(paramIndex))
-      }
-
-      if (altsByTypeTest.size == 1) {
-        // Testing this parameter is not doing any us good
-        genOverloadDispatchSameArgcRec(jsName, formalArgsRegistry, alts, tpe, paramIndex + 1, maxArgc)
-      } else {
-        // Sort them so that, e.g., isInstanceOf[String] comes before isInstanceOf[Object]
-        val sortedAltsByTypeTest = topoSortDistinctsWith(altsByTypeTest) { (lhs, rhs) =>
-          (lhs._1, rhs._1) match {
-            // NoTypeTest is always last
-            case (_, NoTypeTest) => true
-            case (NoTypeTest, _) => false
-
-            case (PrimitiveTypeTest(_, rank1), PrimitiveTypeTest(_, rank2)) =>
-              rank1 <= rank2
-
-            case (InstanceOfTypeTest(t1), InstanceOfTypeTest(t2)) =>
-              t1 <:< t2
-
-            case (_: PrimitiveTypeTest, _: InstanceOfTypeTest) => true
-            case (_: InstanceOfTypeTest, _: PrimitiveTypeTest) => false
-          }
-        }
-
-        val defaultCase = genThrowTypeError()
-
-        sortedAltsByTypeTest.foldRight[js.Tree](defaultCase) { (elem, elsep) =>
-          val (typeTest, subAlts) = elem
-          implicit val pos = subAlts.head.pos
-
-          val paramRef = formalArgsRegistry.genArgRef(paramIndex)
-          val genSubAlts = genOverloadDispatchSameArgcRec(jsName, formalArgsRegistry,
-              subAlts, tpe, paramIndex + 1, maxArgc)
-
-          def hasDefaultParam = subAlts.exists(_.hasDefaultAt(paramIndex))
-
-          val optCond = typeTest match {
-            case PrimitiveTypeTest(tpe, _) => Some(js.IsInstanceOf(paramRef, tpe))
-            case InstanceOfTypeTest(tpe)   => Some(genIsInstanceOf(paramRef, tpe))
-            case NoTypeTest                => None
-          }
-
-          optCond.fold[js.Tree] {
-            genSubAlts // note: elsep is discarded, obviously
-          } { cond =>
-            val condOrUndef = if (!hasDefaultParam) cond else {
-              js.If(cond, js.BooleanLiteral(true),
-                  js.BinaryOp(js.BinaryOp.===, paramRef, js.Undefined()))(
-                  jstpe.BooleanType)
-            }
-            js.If(condOrUndef, genSubAlts, elsep)(tpe)
-          }
-        }
-      }
-    }
-  }
-
-  private def reportCannotDisambiguateError(jsName: JSName, alts: List[Symbol]): Unit = {
-    val currentClass = currentClassSym.get
-
-    /* Find a position that is in the current class for decent error reporting.
-     * If there are more than one, always use the "highest" one (i.e., the
-     * one coming last in the source text) so that we reliably display the
-     * same error in all compilers.
-     */
-    val validPositions = alts.collect {
-      case alt if alt.owner == currentClass => alt.sourcePos
-    }
-    val pos: SourcePosition =
-      if (validPositions.isEmpty) currentClass.sourcePos
-      else validPositions.maxBy(_.point)
-
-    val kind =
-      if (alts.head.isJSGetter) "getter"
-      else if (alts.head.isJSSetter) "setter"
-      else "method"
-
-    val fullKind =
-      if (currentClass.isJSType) kind
-      else "exported " + kind
-
-    val displayName = jsName.displayName
-    val altsTypesInfo = alts.map(_.info.show).sorted.mkString("\n  ")
-
-    report.error(
-        em"Cannot disambiguate overloads for $fullKind $displayName with types\n  $altsTypesInfo",
-        pos)
-  }
-
-  /** Generates a call to the method represented by the given `exported` while using the formalArguments
-   *  and potentially the argument array.
-   *
-   *  Also inserts default parameters if required.
-   */
-  private def genApplyForSingleExported(formalArgsRegistry: FormalArgsRegistry,
-      exported: Exported, static: Boolean): js.Tree = {
-    if (currentClassSym.isJSType && exported.sym.owner != currentClassSym.get) {
-      assert(!static, s"nonsensical JS super call in static export of ${exported.sym}")
-      genApplyForSingleExportedJSSuperCall(formalArgsRegistry, exported)
-    } else {
-      genApplyForSingleExportedNonJSSuperCall(formalArgsRegistry, exported, static)
-    }
-  }
-
-  private def genApplyForSingleExportedJSSuperCall(
-      formalArgsRegistry: FormalArgsRegistry, exported: Exported): js.Tree = {
-    implicit val pos = exported.pos
-
-    val sym = exported.sym
-    assert(!sym.isClassConstructor,
-        s"Trying to genApplyForSingleExportedJSSuperCall for the constructor ${sym.fullName}")
-
-    val allArgs = formalArgsRegistry.genAllArgsRefsForForwarder()
-
-    val superClass = {
-      val superClassSym = currentClassSym.asClass.superClass
-      if (superClassSym.isNestedJSClass)
-        js.VarRef(js.LocalIdent(JSSuperClassParamName))(jstpe.AnyType)
-      else
-        js.LoadJSConstructor(encodeClassName(superClassSym))
-    }
-
-    val receiver = js.This()(currentThisType)
-    val nameTree = genExpr(sym.jsName)
-
-    if (sym.isJSGetter) {
-      assert(allArgs.isEmpty,
-          s"getter symbol $sym does not have a getter signature")
-      js.JSSuperSelect(superClass, receiver, nameTree)
-    } else if (sym.isJSSetter) {
-      assert(allArgs.size == 1 && allArgs.head.isInstanceOf[js.Tree],
-          s"setter symbol $sym does not have a setter signature")
-      js.Assign(js.JSSuperSelect(superClass, receiver, nameTree),
-          allArgs.head.asInstanceOf[js.Tree])
-    } else {
-      js.JSSuperMethodCall(superClass, receiver, nameTree, allArgs)
-    }
-  }
-
-  private def genApplyForSingleExportedNonJSSuperCall(
-      formalArgsRegistry: FormalArgsRegistry, exported: Exported, static: Boolean): js.Tree = {
-
-    implicit val pos = exported.pos
-
-    val varDefs = new mutable.ListBuffer[js.VarDef]
-
-    for ((param, i) <- exported.params.zipWithIndex) {
-      val rhs = genScalaArg(exported, i, formalArgsRegistry, param, static, captures = Nil)(
-          prevArgsCount => varDefs.take(prevArgsCount).toList.map(_.ref))
-
-      varDefs += js.VarDef(freshLocalIdent("prep" + i), NoOriginalName, rhs.tpe, mutable = false, rhs)
-    }
-
-    val builtVarDefs = varDefs.result()
-
-    val jsResult = genResult(exported, builtVarDefs.map(_.ref), static)
-
-    js.Block(builtVarDefs :+ jsResult)
-  }
-
-  /** Generates a Scala argument from dispatched JavaScript arguments
-   *  (unboxing and default parameter handling).
-   */
-  def genScalaArg(exported: Exported, paramIndex: Int, formalArgsRegistry: FormalArgsRegistry,
-      param: JSParamInfo, static: Boolean, captures: List[js.Tree])(
-      previousArgsValues: Int => List[js.Tree])(
-      implicit pos: SourcePosition): js.Tree = {
-
-    if (param.repeated) {
-      genJSArrayToVarArgs(formalArgsRegistry.genVarargRef(paramIndex))
-    } else {
-      val jsArg = formalArgsRegistry.genArgRef(paramIndex)
-
-      // Unboxed argument (if it is defined)
-      val unboxedArg = unbox(jsArg, param.info)
-
-      if (exported.hasDefaultAt(paramIndex)) {
-        // If argument is undefined and there is a default getter, call it
-        js.If(js.BinaryOp(js.BinaryOp.===, jsArg, js.Undefined()), {
-          genCallDefaultGetter(exported.sym, paramIndex, static, captures)(previousArgsValues)
-        }, {
-          unboxedArg
-        })(unboxedArg.tpe)
-      } else {
-        // Otherwise, it is always the unboxed argument
-        unboxedArg
-      }
-    }
-  }
-
-  def genCallDefaultGetter(sym: Symbol, paramIndex: Int,
-      static: Boolean, captures: List[js.Tree])(
-      previousArgsValues: Int => List[js.Tree])(
-      implicit pos: SourcePosition): js.Tree = {
-
-    val targetSym = targetSymForDefaultGetter(sym)
-    val defaultGetterDenot = this.defaultGetterDenot(targetSym, sym, paramIndex)
-
-    assert(defaultGetterDenot.exists, s"need default getter for method ${sym.fullName}")
-    assert(!defaultGetterDenot.isOverloaded, i"found overloaded default getter $defaultGetterDenot")
-    val defaultGetter = defaultGetterDenot.symbol
-
-    val targetTree = {
-      if (sym.isClassConstructor || static) {
-        if (targetSym.isStatic) {
-          assert(captures.isEmpty, i"expected empty captures for ${targetSym.fullName} at $pos")
-          genLoadModule(targetSym)
-        } else {
-          assert(captures.sizeIs == 1, "expected exactly one capture")
-
-          // Find the module accessor. We cannot use memberBasedOnFlags because of scala-js/scala-js#4526.
-          val outer = targetSym.originalOwner
-          val name = atPhase(typerPhase)(targetSym.name.unexpandedName).sourceModuleName
-          val modAccessor = outer.info.allMembers.find { denot =>
-            denot.symbol.is(Module) && denot.name.unexpandedName == name
-          }.getOrElse {
-            throw new AssertionError(i"could not find module accessor for ${targetSym.fullName} at $pos")
-          }.symbol
-
-          val receiver = captures.head
-          if (outer.isJSType)
-            genApplyJSClassMethod(receiver, modAccessor, Nil)
-          else
-            genApplyMethodMaybeStatically(receiver, modAccessor, Nil)
-        }
-      } else {
-        js.This()(currentThisType)
-      }
-    }
-
-    // Pass previous arguments to defaultGetter
-    val defaultGetterArgs = previousArgsValues(defaultGetter.info.paramInfoss.head.size)
-
-    val callGetter = if (targetSym.isJSType) {
-      if (defaultGetter.owner.isNonNativeJSClass) {
-        if (defaultGetter.hasAnnotation(jsdefn.JSOptionalAnnot))
-          js.Undefined()
-        else
-          genApplyJSClassMethod(targetTree, defaultGetter, defaultGetterArgs)
-      } else if (defaultGetter.owner == targetSym) {
-        /* We get here if a non-native constructor has a native companion.
-         * This is reported on a per-class level.
-         */
-        assert(sym.isClassConstructor,
-            s"got non-constructor method $sym with default method in JS native companion")
-        js.Undefined()
-      } else {
-        report.error(
-            "When overriding a native method with default arguments, " +
-            "the overriding method must explicitly repeat the default arguments.",
-            sym.srcPos)
-        js.Undefined()
-      }
-    } else {
-      genApplyMethod(targetTree, defaultGetter, defaultGetterArgs)
-    }
-
-    // #15419 If the getter returns void, we must "box" it by returning undefined
-    if (callGetter.tpe == jstpe.NoType)
-      js.Block(callGetter, js.Undefined())
-    else
-      callGetter
-  }
-
-  private def targetSymForDefaultGetter(sym: Symbol): Symbol =
-    if (sym.isClassConstructor) sym.owner.companionModule.moduleClass
-    else sym.owner
-
-  private def defaultGetterDenot(targetSym: Symbol, sym: Symbol, paramIndex: Int): Denotation =
-    targetSym.info.memberBasedOnFlags(DefaultGetterName(sym.name.asTermName, paramIndex), excluded = Bridge)
-
-  private def defaultGetterDenot(sym: Symbol, paramIndex: Int): Denotation =
-    defaultGetterDenot(targetSymForDefaultGetter(sym), sym, paramIndex)
-
-  /** Generate the final forwarding call to the exported method. */
-  private def genResult(exported: Exported, args: List[js.Tree], static: Boolean)(
-      implicit pos: SourcePosition): js.Tree = {
-
-    val sym = exported.sym
-    val currentClass = currentClassSym.get
-
-    def receiver =
-      if (static) genLoadModule(sym.owner)
-      else js.This()(currentThisType)
-
-    def boxIfNeeded(call: js.Tree): js.Tree =
-      box(call, atPhase(elimErasedValueTypePhase)(sym.info.resultType))
-
-    if (currentClass.isNonNativeJSClass) {
-      assert(sym.owner == currentClass, sym.fullName)
-      boxIfNeeded(genApplyJSClassMethod(receiver, sym, args))
-    } else {
-      if (sym.isClassConstructor)
-        js.New(encodeClassName(currentClass), encodeMethodSym(sym), args)
-      else if (sym.isPrivate)
-        boxIfNeeded(genApplyMethodStatically(receiver, sym, args))
-      else
-        boxIfNeeded(genApplyMethod(receiver, sym, args))
-    }
-  }
-
-  private def genThrowTypeError(msg: String = "No matching overload")(implicit pos: Position): js.Tree =
-    js.Throw(js.JSNew(js.JSGlobalRef("TypeError"), js.StringLiteral(msg) :: Nil))
-
-  abstract class Exported(
-    val sym: Symbol,
-    // Parameters participating in overload resolution.
-    val params: scala.collection.immutable.IndexedSeq[JSParamInfo]
-  ) {
-    assert(!params.exists(_.capture), "illegal capture params in Exported")
-
-    private val paramsHasDefault = {
-      if (!atPhase(elimRepeatedPhase)(sym.hasDefaultParams)) {
-        Vector.empty
-      } else {
-        val targetSym = targetSymForDefaultGetter(sym)
-        params.indices.map(i => defaultGetterDenot(targetSym, sym, i).exists)
-      }
-    }
-
-    def hasDefaultAt(paramIndex: Int): Boolean =
-      paramIndex < paramsHasDefault.size && paramsHasDefault(paramIndex)
-
-    val hasRepeatedParam = params.nonEmpty && params.last.repeated
-
-    val minArgc = {
-      // Find the first default param or repeated param
-      params
-        .indices
-        .find(i => hasDefaultAt(i) || params(i).repeated)
-        .getOrElse(params.size)
-    }
-
-    val maxNonRepeatedArgc = if (hasRepeatedParam) params.size - 1 else params.size
-
-    def pos: SourcePosition = sym.sourcePos
-
-    def exportArgTypeAt(paramIndex: Int): Type = {
-      if (paramIndex < params.length) {
-        params(paramIndex).info
-      } else {
-        assert(hasRepeatedParam, i"$sym does not have varargs nor enough params for $paramIndex")
-        params.last.info
-      }
-    }
-
-    def typeInfo: String = sym.info.toString
-
-    def genBody(formalArgsRegistry: FormalArgsRegistry): js.Tree
-  }
-
-  private class ExportedSymbol(sym: Symbol, static: Boolean)
-      extends Exported(sym, sym.jsParamInfos.toIndexedSeq) {
-
-    def genBody(formalArgsRegistry: FormalArgsRegistry): js.Tree =
-      genApplyForSingleExported(formalArgsRegistry, this, static)
-  }
-
-  // !!! Hash codes of RTTypeTest are meaningless because of InstanceOfTypeTest
-  private sealed abstract class RTTypeTest
-
-  private case class PrimitiveTypeTest(tpe: jstpe.Type, rank: Int) extends RTTypeTest
-
-  // !!! This class does not have a meaningful hash code
-  private case class InstanceOfTypeTest(tpe: Type) extends RTTypeTest {
-    override def equals(that: Any): Boolean = {
-      that match {
-        case InstanceOfTypeTest(thatTpe) => tpe =:= thatTpe
-        case _                           => false
-      }
-    }
-  }
-
-  private case object NoTypeTest extends RTTypeTest
-
-  /** Very simple O(n²) topological sort for elements assumed to be distinct. */
-  private def topoSortDistinctsWith[A <: AnyRef](coll: List[A])(lteq: (A, A) => Boolean): List[A] = {
-    @tailrec
-    def loop(coll: List[A], acc: List[A]): List[A] = {
-      if (coll.isEmpty) acc
-      else if (coll.tail.isEmpty) coll.head :: acc
-      else {
-        val (lhs, rhs) = coll.span(x => !coll.forall(y => (x eq y) || !lteq(x, y)))
-        assert(!rhs.isEmpty, s"cycle while ordering $coll")
-        loop(lhs ::: rhs.tail, rhs.head :: acc)
-      }
-    }
-
-    loop(coll, Nil)
-  }
-
-  private def typeTestForTpe(tpe: Type): RTTypeTest = {
-    tpe match {
-      case tpe: ErasedValueType =>
-        InstanceOfTypeTest(tpe.tycon.typeSymbol.typeRef)
-
-      case _ =>
-        import dotty.tools.sjs.ir.Names
-
-        (toIRType(tpe): @unchecked) match {
-          case jstpe.AnyType => NoTypeTest
-
-          case jstpe.NoType      => PrimitiveTypeTest(jstpe.UndefType, 0)
-          case jstpe.BooleanType => PrimitiveTypeTest(jstpe.BooleanType, 1)
-          case jstpe.CharType    => PrimitiveTypeTest(jstpe.CharType, 2)
-          case jstpe.ByteType    => PrimitiveTypeTest(jstpe.ByteType, 3)
-          case jstpe.ShortType   => PrimitiveTypeTest(jstpe.ShortType, 4)
-          case jstpe.IntType     => PrimitiveTypeTest(jstpe.IntType, 5)
-          case jstpe.LongType    => PrimitiveTypeTest(jstpe.LongType, 6)
-          case jstpe.FloatType   => PrimitiveTypeTest(jstpe.FloatType, 7)
-          case jstpe.DoubleType  => PrimitiveTypeTest(jstpe.DoubleType, 8)
-
-          case jstpe.ClassType(Names.BoxedUnitClass)   => PrimitiveTypeTest(jstpe.UndefType, 0)
-          case jstpe.ClassType(Names.BoxedStringClass) => PrimitiveTypeTest(jstpe.StringType, 9)
-          case jstpe.ClassType(_)                      => InstanceOfTypeTest(tpe)
-
-          case jstpe.ArrayType(_) => InstanceOfTypeTest(tpe)
-        }
-    }
-  }
-
-  // Group-by that does not rely on hashCode(), only equals() - O(n²)
-  private def groupByWithoutHashCode[A, B](coll: List[A])(f: A => B): List[(B, List[A])] = {
-    val m = new mutable.ArrayBuffer[(B, List[A])]
-    m.sizeHint(coll.length)
-
-    for (elem <- coll) {
-      val key = f(elem)
-      val index = m.indexWhere(_._1 == key)
-      if (index < 0)
-        m += ((key, List(elem)))
-      else
-        m(index) = (key, elem :: m(index)._2)
-    }
-
-    m.toList
-  }
-
-  class FormalArgsRegistry(val minArgc: Int, needsRestParam: Boolean) {
-    private val fixedParamNames: scala.collection.immutable.IndexedSeq[jsNames.LocalName] =
-      (0 until minArgc).toIndexedSeq.map(_ => freshLocalIdent("arg")(NoPosition).name)
-
-    private val restParamName: jsNames.LocalName =
-      if (needsRestParam) freshLocalIdent("rest")(NoPosition).name
-      else null
-
-    def genFormalArgs()(implicit pos: Position): (List[js.ParamDef], Option[js.ParamDef]) = {
-      val fixedParamDefs = fixedParamNames.toList.map { paramName =>
-        js.ParamDef(js.LocalIdent(paramName), NoOriginalName, jstpe.AnyType, mutable = false)
-      }
-
-      val restParam = {
-        if (needsRestParam)
-          Some(js.ParamDef(js.LocalIdent(restParamName), NoOriginalName, jstpe.AnyType, mutable = false))
-        else
-          None
-      }
-
-      (fixedParamDefs, restParam)
-    }
-
-    def genArgRef(index: Int)(implicit pos: Position): js.Tree = {
-      if (index < minArgc)
-        js.VarRef(js.LocalIdent(fixedParamNames(index)))(jstpe.AnyType)
-      else
-        js.JSSelect(genRestArgRef(), js.IntLiteral(index - minArgc))
-    }
-
-    def genVarargRef(fixedParamCount: Int)(implicit pos: Position): js.Tree = {
-      assert(fixedParamCount >= minArgc, s"genVarargRef($fixedParamCount) with minArgc = $minArgc at $pos")
-      val restParam = genRestArgRef()
-      if (fixedParamCount == minArgc)
-        restParam
-      else
-        js.JSMethodApply(restParam, js.StringLiteral("slice"), List(js.IntLiteral(fixedParamCount - minArgc)))
-    }
-
-    def genRestArgRef()(implicit pos: Position): js.Tree = {
-      assert(needsRestParam, s"trying to generate a reference to non-existent rest param at $pos")
-      js.VarRef(js.LocalIdent(restParamName))(jstpe.AnyType)
-    }
-
-    def genAllArgsRefsForForwarder()(implicit pos: Position): List[js.TreeOrJSSpread] = {
-      val fixedArgRefs = fixedParamNames.toList.map { paramName =>
-        js.VarRef(js.LocalIdent(paramName))(jstpe.AnyType)
-      }
-
-      if (needsRestParam) {
-        val restArgRef = js.VarRef(js.LocalIdent(restParamName))(jstpe.AnyType)
-        fixedArgRefs :+ js.JSSpread(restArgRef)
-      } else {
-        fixedArgRefs
-      }
-    }
-  }
-}
diff --git a/tests/pos-with-compiler-cc/backend/sjs/JSPositions.scala b/tests/pos-with-compiler-cc/backend/sjs/JSPositions.scala
deleted file mode 100644
index 620e76ab4bab..000000000000
--- a/tests/pos-with-compiler-cc/backend/sjs/JSPositions.scala
+++ /dev/null
@@ -1,102 +0,0 @@
-package dotty.tools.backend.sjs
-
-import scala.language.unsafeNulls
-
-import java.net.{URI, URISyntaxException}
-
-import dotty.tools.dotc.core._
-import Contexts._
-import Decorators.em
-
-import dotty.tools.dotc.report
-
-import dotty.tools.dotc.util.{SourceFile, SourcePosition}
-import dotty.tools.dotc.util.Spans.Span
-
-import dotty.tools.sjs.ir
-
-/** Conversion utilities from dotty Positions to IR Positions. */
-class JSPositions()(using Context) {
-  import JSPositions._
-
-  private val sourceURIMaps: List[URIMap] = {
-    ctx.settings.scalajsMapSourceURI.value.flatMap { option =>
-      val uris = option.split("->")
-      if (uris.length != 1 && uris.length != 2) {
-        report.error("-scalajs-mapSourceURI needs one or two URIs as argument (separated by '->').")
-        Nil
-      } else {
-        try {
-          val from = new URI(uris.head)
-          val to = uris.lift(1).map(str => new URI(str))
-          URIMap(from, to) :: Nil
-        } catch {
-          case e: URISyntaxException =>
-            report.error(em"${e.getInput} is not a valid URI")
-            Nil
-        }
-      }
-    }
-  }
-
-  private def sourceAndSpan2irPos(source: SourceFile, span: Span): ir.Position = {
-    if (!span.exists) ir.Position.NoPosition
-    else {
-      // dotty positions and IR positions are both 0-based
-      val irSource = span2irPosCache.toIRSource(source)
-      val point = span.point
-      val line = source.offsetToLine(point)
-      val column = source.column(point)
-      ir.Position(irSource, line, column)
-    }
-  }
-
-  /** Implicit conversion from dotty Span to ir.Position. */
-  implicit def span2irPos(span: Span): ir.Position =
-    sourceAndSpan2irPos(ctx.compilationUnit.source, span)
-
-  /** Implicitly materializes an ir.Position from an implicit dotty Span. */
-  implicit def implicitSpan2irPos(implicit span: Span): ir.Position =
-    span2irPos(span)
-
-  /** Implicitly materializes an ir.Position from an implicit dotty SourcePosition. */
-  implicit def implicitSourcePos2irPos(implicit sourcePos: SourcePosition): ir.Position =
-    sourceAndSpan2irPos(sourcePos.source, sourcePos.span)
-
-  private object span2irPosCache {
-    import dotty.tools.dotc.util._
-
-    private var lastDotcSource: SourceFile = null
-    private var lastIRSource: ir.Position.SourceFile = null
-
-    def toIRSource(dotcSource: SourceFile): ir.Position.SourceFile = {
-      if (dotcSource != lastDotcSource) {
-        lastIRSource = convert(dotcSource)
-        lastDotcSource = dotcSource
-      }
-      lastIRSource
-    }
-
-    private def convert(dotcSource: SourceFile): ir.Position.SourceFile = {
-      dotcSource.file.file match {
-        case null =>
-          new java.net.URI(
-              "virtualfile",        // Pseudo-Scheme
-              dotcSource.file.path, // Scheme specific part
-              null                  // Fragment
-          )
-        case file =>
-          val srcURI = file.toURI
-          sourceURIMaps.collectFirst {
-            case URIMap(from, to) if from.relativize(srcURI) != srcURI =>
-              val relURI = from.relativize(srcURI)
-              to.fold(relURI)(_.resolve(relURI))
-          }.getOrElse(srcURI)
-      }
-    }
-  }
-}
-
-object JSPositions {
-  final case class URIMap(from: URI, to: Option[URI])
-}
diff --git a/tests/pos-with-compiler-cc/backend/sjs/JSPrimitives.scala b/tests/pos-with-compiler-cc/backend/sjs/JSPrimitives.scala
deleted file mode 100644
index ce83f5e9e83b..000000000000
--- a/tests/pos-with-compiler-cc/backend/sjs/JSPrimitives.scala
+++ /dev/null
@@ -1,150 +0,0 @@
-package dotty.tools.backend.sjs
-
-import dotty.tools.dotc.core._
-import Names.TermName
-import Types._
-import Contexts._
-import Symbols._
-import Decorators.em
-
-import dotty.tools.dotc.ast.tpd._
-import dotty.tools.backend.jvm.DottyPrimitives
-import dotty.tools.dotc.report
-import dotty.tools.dotc.util.ReadOnlyMap
-
-object JSPrimitives {
-
-  inline val FirstJSPrimitiveCode = 300
-
-  inline val DYNNEW = FirstJSPrimitiveCode + 1 // Instantiate a new JavaScript object
-
-  inline val ARR_CREATE = DYNNEW + 1 // js.Array.apply (array literal syntax)
-
-  inline val TYPEOF = ARR_CREATE + 1 // typeof x
-  inline val JS_NATIVE = TYPEOF + 1  // js.native. Marker method. Fails if tried to be emitted.
-
-  inline val UNITVAL = JS_NATIVE + 1 // () value, which is undefined
-
-  inline val JS_NEW_TARGET = UNITVAL + 1 // js.new.target
-
-  inline val JS_IMPORT = JS_NEW_TARGET + 1  // js.import.apply(specifier)
-  inline val JS_IMPORT_META = JS_IMPORT + 1 // js.import.meta
-
-  inline val CONSTRUCTOROF = JS_IMPORT_META + 1                         // runtime.constructorOf(clazz)
-  inline val CREATE_INNER_JS_CLASS = CONSTRUCTOROF + 1                  // runtime.createInnerJSClass
-  inline val CREATE_LOCAL_JS_CLASS = CREATE_INNER_JS_CLASS + 1          // runtime.createLocalJSClass
-  inline val WITH_CONTEXTUAL_JS_CLASS_VALUE = CREATE_LOCAL_JS_CLASS + 1 // runtime.withContextualJSClassValue
-  inline val LINKING_INFO = WITH_CONTEXTUAL_JS_CLASS_VALUE + 1          // runtime.linkingInfo
-  inline val DYNAMIC_IMPORT = LINKING_INFO + 1                          // runtime.dynamicImport
-
-  inline val STRICT_EQ = DYNAMIC_IMPORT + 1                // js.special.strictEquals
-  inline val IN = STRICT_EQ + 1                            // js.special.in
-  inline val INSTANCEOF = IN + 1                           // js.special.instanceof
-  inline val DELETE = INSTANCEOF + 1                       // js.special.delete
-  inline val FORIN = DELETE + 1                            // js.special.forin
-  inline val JS_THROW = FORIN + 1                          // js.special.throw
-  inline val JS_TRY_CATCH = JS_THROW + 1                   // js.special.tryCatch
-  inline val WRAP_AS_THROWABLE = JS_TRY_CATCH + 1          // js.special.wrapAsThrowable
-  inline val UNWRAP_FROM_THROWABLE = WRAP_AS_THROWABLE + 1 // js.special.unwrapFromThrowable
-  inline val DEBUGGER = UNWRAP_FROM_THROWABLE + 1          // js.special.debugger
-
-  inline val THROW = DEBUGGER + 1
-
-  inline val UNION_FROM = THROW + 1                       // js.|.from
-  inline val UNION_FROM_TYPE_CONSTRUCTOR = UNION_FROM + 1 // js.|.fromTypeConstructor
-
-  inline val REFLECT_SELECTABLE_SELECTDYN = UNION_FROM_TYPE_CONSTRUCTOR + 1 // scala.reflect.Selectable.selectDynamic
-  inline val REFLECT_SELECTABLE_APPLYDYN = REFLECT_SELECTABLE_SELECTDYN + 1 // scala.reflect.Selectable.applyDynamic
-
-  inline val LastJSPrimitiveCode = REFLECT_SELECTABLE_APPLYDYN
-
-  def isJSPrimitive(code: Int): Boolean =
-    code >= FirstJSPrimitiveCode && code <= LastJSPrimitiveCode
-
-}
-
-class JSPrimitives(ictx: DetachedContext) extends DottyPrimitives(ictx) {
-  import JSPrimitives._
-
-  private lazy val jsPrimitives: ReadOnlyMap[Symbol, Int] = initJSPrimitives(using ictx)
-
-  override def getPrimitive(sym: Symbol): Int =
-    jsPrimitives.getOrElse(sym, super.getPrimitive(sym))
-
-  override def getPrimitive(app: Apply, tpe: Type)(using Context): Int =
-    jsPrimitives.getOrElse(app.fun.symbol, super.getPrimitive(app, tpe))
-
-  override def isPrimitive(sym: Symbol): Boolean =
-    jsPrimitives.contains(sym) || super.isPrimitive(sym)
-
-  override def isPrimitive(fun: Tree): Boolean =
-    jsPrimitives.contains(fun.symbol(using ictx)) || super.isPrimitive(fun)
-
-  /** Initialize the primitive map */
-  private def initJSPrimitives(using Context): ReadOnlyMap[Symbol, Int] = {
-
-    val primitives = MutableSymbolMap[Int]()
-
-    // !!! Code duplicate with DottyPrimitives
-    /** Add a primitive operation to the map */
-    def addPrimitive(s: Symbol, code: Int): Unit = {
-      assert(!(primitives contains s), "Duplicate primitive " + s)
-      primitives(s) = code
-    }
-
-    def addPrimitives(cls: Symbol, method: TermName, code: Int)(using Context): Unit = {
-      val alts = cls.info.member(method).alternatives.map(_.symbol)
-      if (alts.isEmpty) {
-        report.error(em"Unknown primitive method $cls.$method")
-      } else {
-        for (s <- alts)
-          addPrimitive(s, code)
-      }
-    }
-
-    val jsdefn = JSDefinitions.jsdefn
-
-    addPrimitive(jsdefn.JSDynamic_newInstance, DYNNEW)
-
-    addPrimitive(jsdefn.JSArray_apply, ARR_CREATE)
-
-    addPrimitive(jsdefn.JSPackage_typeOf, TYPEOF)
-    addPrimitive(jsdefn.JSPackage_native, JS_NATIVE)
-
-    addPrimitive(defn.BoxedUnit_UNIT, UNITVAL)
-
-    addPrimitive(jsdefn.JSNew_target, JS_NEW_TARGET)
-
-    addPrimitive(jsdefn.JSImport_apply, JS_IMPORT)
-    addPrimitive(jsdefn.JSImport_meta, JS_IMPORT_META)
-
-    addPrimitive(jsdefn.Runtime_constructorOf, CONSTRUCTOROF)
-    addPrimitive(jsdefn.Runtime_createInnerJSClass, CREATE_INNER_JS_CLASS)
-    addPrimitive(jsdefn.Runtime_createLocalJSClass, CREATE_LOCAL_JS_CLASS)
-    addPrimitive(jsdefn.Runtime_withContextualJSClassValue, WITH_CONTEXTUAL_JS_CLASS_VALUE)
-    addPrimitive(jsdefn.Runtime_linkingInfo, LINKING_INFO)
-    addPrimitive(jsdefn.Runtime_dynamicImport, DYNAMIC_IMPORT)
-
-    addPrimitive(jsdefn.Special_strictEquals, STRICT_EQ)
-    addPrimitive(jsdefn.Special_in, IN)
-    addPrimitive(jsdefn.Special_instanceof, INSTANCEOF)
-    addPrimitive(jsdefn.Special_delete, DELETE)
-    addPrimitive(jsdefn.Special_forin, FORIN)
-    addPrimitive(jsdefn.Special_throw, JS_THROW)
-    addPrimitive(jsdefn.Special_tryCatch, JS_TRY_CATCH)
-    addPrimitive(jsdefn.Special_wrapAsThrowable, WRAP_AS_THROWABLE)
-    addPrimitive(jsdefn.Special_unwrapFromThrowable, UNWRAP_FROM_THROWABLE)
-    addPrimitive(jsdefn.Special_debugger, DEBUGGER)
-
-    addPrimitive(defn.throwMethod, THROW)
-
-    addPrimitive(jsdefn.PseudoUnion_from, UNION_FROM)
-    addPrimitive(jsdefn.PseudoUnion_fromTypeConstructor, UNION_FROM_TYPE_CONSTRUCTOR)
-
-    addPrimitive(jsdefn.ReflectSelectable_selectDynamic, REFLECT_SELECTABLE_SELECTDYN)
-    addPrimitive(jsdefn.ReflectSelectable_applyDynamic, REFLECT_SELECTABLE_APPLYDYN)
-
-    primitives
-  }
-
-}
diff --git a/tests/pos-with-compiler-cc/backend/sjs/ScopedVar.scala b/tests/pos-with-compiler-cc/backend/sjs/ScopedVar.scala
deleted file mode 100644
index af7570a6edca..000000000000
--- a/tests/pos-with-compiler-cc/backend/sjs/ScopedVar.scala
+++ /dev/null
@@ -1,38 +0,0 @@
-package dotty.tools.backend.sjs
-
-class ScopedVar[A](init: A) extends Pure {
-  import ScopedVar.Assignment
-
-  private[ScopedVar] var value = init
-
-  def this()(implicit ev: Null <:< A) = this(ev(null))
-
-  def get: A = value
-  def :=(newValue: A): Assignment[A] = new Assignment(this, newValue)
-}
-
-object ScopedVar {
-  class Assignment[T](scVar: ScopedVar[T], value: T) {
-    private[ScopedVar] def push(): AssignmentStackElement[T] = {
-      val stack = new AssignmentStackElement(scVar, scVar.value)
-      scVar.value = value
-      stack
-    }
-  }
-
-  private class AssignmentStackElement[T](scVar: ScopedVar[T], oldValue: T) {
-    private[ScopedVar] def pop(): Unit = {
-      scVar.value = oldValue
-    }
-  }
-
-  implicit def toValue[T](scVar: ScopedVar[T]): T = scVar.get
-
-  def withScopedVars[T](ass: Assignment[_]*)(body: => T): T = {
-    val stack = ass.map(_.push())
-    try body
-    finally stack.reverse.foreach(_.pop())
-  }
-
-  final class VarBox[A](var value: A)
-}
diff --git a/tests/pos-with-compiler-cc/dotc/Bench.scala b/tests/pos-with-compiler-cc/dotc/Bench.scala
deleted file mode 100644
index c9c032b0ae7d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/Bench.scala
+++ /dev/null
@@ -1,64 +0,0 @@
-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
deleted file mode 100644
index ad51305d5858..000000000000
--- a/tests/pos-with-compiler-cc/dotc/CompilationUnit.scala
+++ /dev/null
@@ -1,167 +0,0 @@
-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
-import language.experimental.pureFunctions
-
-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 throwing 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(em"expected file, received directory '${source.file.path}'")
-        NoSource
-      }
-      else if (!source.file.exists) {
-        report.error(em"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
deleted file mode 100644
index c8c95647b5e4..000000000000
--- a/tests/pos-with-compiler-cc/dotc/Compiler.scala
+++ /dev/null
@@ -1,171 +0,0 @@
-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 implementation 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
deleted file mode 100644
index b85f1365243b..000000000000
--- a/tests/pos-with-compiler-cc/dotc/Driver.scala
+++ /dev/null
@@ -1,207 +0,0 @@
-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], DetachedContext)] = {
-    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).detach)
-      }
-    }
-  }
-
-  /** 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(em"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(em"Could not load classname from: ${file.path}")
-                  None
-            case _ =>
-              report.error(em"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
deleted file mode 100644
index 3288fded52a2..000000000000
--- a/tests/pos-with-compiler-cc/dotc/Main.scala
+++ /dev/null
@@ -1,5 +0,0 @@
-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
deleted file mode 100644
index ae20d81226c9..000000000000
--- a/tests/pos-with-compiler-cc/dotc/MissingCoreLibraryException.scala
+++ /dev/null
@@ -1,9 +0,0 @@
-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
deleted file mode 100644
index 9ebeaaaeb1c2..000000000000
--- a/tests/pos-with-compiler-cc/dotc/Resident.scala
+++ /dev/null
@@ -1,61 +0,0 @@
-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: DetachedContext = ctx
-          var line = getLine()
-          while (line == reset) {
-            nextCtx = rootCtx.detach
-            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
deleted file mode 100644
index 96f8c6a7b06f..000000000000
--- a/tests/pos-with-compiler-cc/dotc/Run.scala
+++ /dev/null
@@ -1,404 +0,0 @@
-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 annotation.constructorOnly
-import annotation.unchecked.uncheckedCaptures
-
-/** A compiler run. Exports various methods to compile source files */
-class Run(comp: Compiler, @constructorOnly ictx0: Context) extends ImplicitRunInfo with ConstraintRunInfo {
-
-  val ictx = ictx0.detach
-
-  /** 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 */
-  @uncheckedCaptures
-  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 codec = Codec(runContext.settings.encoding.value)
-      val sources = files.map(runContext.getSource(_, codec))
-      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)
-      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 codec = Codec(ctx.settings.encoding.value)
-      val unit = CompilationUnit(ctx.getSource(file, codec))
-      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): DetachedContext = {
-    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).detach
-  }
-
-  private var myCtx: DetachedContext | Null = rootContext(using ictx)
-
-  /** The context created for this run */
-  given runContext[Dummy_so_its_a_def]: DetachedContext = 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
deleted file mode 100644
index 2e0d9a08f25d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/ScalacCommand.scala
+++ /dev/null
@@ -1,9 +0,0 @@
-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
deleted file mode 100644
index 6bf7530faf24..000000000000
--- a/tests/pos-with-compiler-cc/dotc/ast/CheckTrees.scala.disabled
+++ /dev/null
@@ -1,258 +0,0 @@
-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
deleted file mode 100644
index 390e58d89245..000000000000
--- a/tests/pos-with-compiler-cc/dotc/ast/Desugar.scala
+++ /dev/null
@@ -1,1979 +0,0 @@
-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 Annotations.Annotation
-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 dctx = ctx.detach
-      val relocate = new TypeMap(using dctx) {
-        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.detach.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 =
-                em"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 valName = normalizeName(vdef, tpt).asTermName
-    var mods1 = vdef.mods
-
-    def dropInto(tpt: Tree): Tree = tpt match
-      case Into(tpt1) =>
-        mods1 = vdef.mods.withAddedAnnotation(
-          TypedSplice(
-            Annotation(defn.AllowConversionsAnnot).tree.withSpan(tpt.span.startPos)))
-        tpt1
-      case ByNameTypeTree(tpt1) =>
-        cpy.ByNameTypeTree(tpt)(dropInto(tpt1))
-      case PostfixOp(tpt1, op) if op.name == tpnme.raw.STAR =>
-        cpy.PostfixOp(tpt)(dropInto(tpt1), op)
-      case _ =>
-        tpt
-
-    val vdef1 = cpy.ValDef(vdef)(name = valName, tpt = dropInto(tpt))
-      .withMods(mods1)
-
-    if isSetterNeeded(vdef) then
-      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((vdef.mods | Accessor) &~ (CaseAccessor | GivenOrImplicit | Lazy))
-        .dropEndMarker() // the end marker should only appear on the getter definition
-      Thicket(vdef1, setter)
-    else vdef1
-  end valDef
-
-  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(em"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.""", 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(em"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.collectCC {
-      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
deleted file mode 100644
index a1c3c0ed0775..000000000000
--- a/tests/pos-with-compiler-cc/dotc/ast/DesugarEnums.scala
+++ /dev/null
@@ -1,310 +0,0 @@
-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(em"""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(em"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
deleted file mode 100644
index c0cf2c0d1b81..000000000000
--- a/tests/pos-with-compiler-cc/dotc/ast/MainProxies.scala
+++ /dev/null
@@ -1,449 +0,0 @@
-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(em"@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(em"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(em"@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(em"@main method cannot have type parameters", pos)
-        case _ =>
-          report.error(em"@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(em"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(em"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(em"main method cannot have implicit parameters", pos)
-          None
-        else mt.resType match
-          case restpe: MethodType =>
-            report.error(em"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(em"main method cannot have type parameters", pos)
-        None
-      case _ =>
-        report.error(em"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
deleted file mode 100644
index 054ffe66f323..000000000000
--- a/tests/pos-with-compiler-cc/dotc/ast/NavigateAST.scala
+++ /dev/null
@@ -1,129 +0,0 @@
-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
deleted file mode 100644
index 7b558c65e425..000000000000
--- a/tests/pos-with-compiler-cc/dotc/ast/Positioned.scala
+++ /dev/null
@@ -1,246 +0,0 @@
-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, 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
deleted file mode 100644
index b650a0088de4..000000000000
--- a/tests/pos-with-compiler-cc/dotc/ast/TreeInfo.scala
+++ /dev/null
@@ -1,1070 +0,0 @@
-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] { self: Trees.Instance[T] =>
-
-  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 _ =>
-        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
deleted file mode 100644
index caf8d68442f6..000000000000
--- a/tests/pos-with-compiler-cc/dotc/ast/TreeMapWithImplicits.scala
+++ /dev/null
@@ -1,82 +0,0 @@
-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
deleted file mode 100644
index 3b250118f9b3..000000000000
--- a/tests/pos-with-compiler-cc/dotc/ast/TreeTypeMap.scala
+++ /dev/null
@@ -1,232 +0,0 @@
-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 DetachedContext) 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
deleted file mode 100644
index 0b1842603316..000000000000
--- a/tests/pos-with-compiler-cc/dotc/ast/Trees.scala
+++ /dev/null
@@ -1,1787 +0,0 @@
-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 compiletime.uninitialized
-import Decorators._
-import annotation.retains
-import language.experimental.pureFunctions
-
-object Trees {
-
-  type Untyped = Type | Null
-
-  /** 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 {
-
-    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 = uninitialized
-
-    /** 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 @uncheckedVariance): 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 =
-      if myTpe == null then throw UnAssignedTypeException(this)
-      myTpe.uncheckedNN
-
-    /** 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 null => 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 >: T <: Untyped](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 = uninitialized
-
-    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])(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])(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])(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[U >: T <: Untyped](op: Tree[T] => Tree[U]): Thicket[U] = {
-      val newTrees = trees.mapConserve(op)
-      if (trees eq newTrees)
-        this
-      else
-        Thicket[U](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] { 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: tpd.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: TreeMap @retains(caps.cap) =>
-      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.cap) =>
-      // 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(em"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
deleted file mode 100644
index f778824a18d3..000000000000
--- a/tests/pos-with-compiler-cc/dotc/ast/tpd.scala
+++ /dev/null
@@ -1,1546 +0,0 @@
-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 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.detach).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(em"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
deleted file mode 100644
index a6d3bc5a072c..000000000000
--- a/tests/pos-with-compiler-cc/dotc/ast/untpd.scala
+++ /dev/null
@@ -1,829 +0,0 @@
-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 =
-      val owner = ctx.owner
-      given SourceFile = ctx.source
-      new TypedSplice(tree)(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 Into(tpt: 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] -> Context ?-> 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 Into(tree: Tree)(tpt: Tree)(using Context): Tree = tree match
-      case tree: Into if tpt eq tree.tpt => tree
-      case _ => finalize(tree, untpd.Into(tpt)(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 Into(tpt) =>
-        cpy.Into(tree)(transform(tpt))
-      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.cap) =>
-    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 Into(tpt) =>
-        this(x, tpt)
-      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
deleted file mode 100644
index 56b3f5ba5047..000000000000
--- a/tests/pos-with-compiler-cc/dotc/cc/BoxedTypeCache.scala
+++ /dev/null
@@ -1,19 +0,0 @@
-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
deleted file mode 100644
index 67222f07efbb..000000000000
--- a/tests/pos-with-compiler-cc/dotc/cc/CaptureAnnotation.scala
+++ /dev/null
@@ -1,77 +0,0 @@
-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
-import annotation.retains
-
-/** 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 @retains(caps.cap))(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
deleted file mode 100644
index 0ede1825e611..000000000000
--- a/tests/pos-with-compiler-cc/dotc/cc/CaptureOps.scala
+++ /dev/null
@@ -1,256 +0,0 @@
-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 (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
-   *  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
deleted file mode 100644
index 2072b43089fb..000000000000
--- a/tests/pos-with-compiler-cc/dotc/cc/CaptureSet.scala
+++ /dev/null
@@ -1,902 +0,0 @@
-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
-import annotation.retains
-
-/** 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, 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", capt)(using null)
-
-  /** 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: (c: Context) ?-> (CaptureRef -> Boolean) @retains(c))(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).detach)
-
-  /** 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)
-
-  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) && (origin ne initial) && 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(em"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)(using null)
-          }
-
-    /** 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.detach)
-      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: (c: Context) ?-> (CaptureRef -> Boolean) @retains(c))(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 @constructorOnly ctx: Context)
-  extends Filtered(source, !other.accountsFor(_))
-
-  class Intersected(cs1: CaptureSet, cs2: CaptureSet)(using @constructorOnly ctx: 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
deleted file mode 100644
index e9862f1f20b8..000000000000
--- a/tests/pos-with-compiler-cc/dotc/cc/CapturingType.scala
+++ /dev/null
@@ -1,72 +0,0 @@
-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
deleted file mode 100644
index ce3f788202b6..000000000000
--- a/tests/pos-with-compiler-cc/dotc/cc/CheckCaptures.scala
+++ /dev/null
@@ -1,1039 +0,0 @@
-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 DetachedContext)
-  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.detach)
-
-  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: DetachedContext) 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)(using null)
-
-    /** 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(em"$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(em"$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)
-        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
-
-    /** 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 = alignDependentFunction(addOuterRefs(expected, actual), actual.stripCapturing)
-      val actual1 = adaptBoxed(actual, expected1, tree.srcPos)
-      //println(i"check conforms $actual1 <<< $expected1")
-      super.checkConformsExpr(actual1, expected1, tree)
-
-    private def toDepFun(args: List[Type], resultType: Type, isContextual: Boolean, isErased: Boolean)(using Context): Type =
-      MethodType.companion(isContextual = isContextual, isErased = isErased)(args, resultType)
-        .toFunctionType(isJava = false, alwaysDependent = true)
-
-    /** Turn `expected` into a dependent function when `actual` is dependent. */
-    private def alignDependentFunction(expected: Type, actual: Type)(using Context): Type =
-      def recur(expected: Type): Type = expected.dealias match
-        case expected @ CapturingType(eparent, refs) =>
-          CapturingType(recur(eparent), refs, boxed = expected.isBoxed)
-        case expected @ defn.FunctionOf(args, resultType, isContextual, isErased)
-          if defn.isNonRefinedFunction(expected) && defn.isFunctionType(actual) && !defn.isNonRefinedFunction(actual) =>
-          val expected1 = toDepFun(args, resultType, isContextual, isErased)
-          expected1
-        case _ =>
-          expected
-      recur(expected)
-
-    /** 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 -> Context ?-> Type = (x: Type) => x) // !cc! need monomorphic default argument
-          : (Type, CaptureSet, Boolean, Type -> Context ?-> 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 -> Context ?-> 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(
-                  em"""$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
-
-    /** Heal ill-formed capture sets in the type parameter.
-     *
-     *  We can push parameter refs into a capture set in type parameters
-     *  that this type parameter can't see.
-     *  For example, when capture checking the following expression:
-     *
-     *    def usingLogFile[T](op: (f: {*} File) => T): T = ...
-     *
-     *    usingLogFile[box ?1 () -> Unit] { (f: {*} File) => () => { f.write(0) } }
-     *
-     *  We may propagate `f` into ?1, making ?1 ill-formed.
-     *  This also causes soundness issues, since `f` in ?1 should be widened to `*`,
-     *  giving rise to an error that `*` cannot be included in a boxed capture set.
-     *
-     *  To solve this, we still allow ?1 to capture parameter refs like `f`, but
-     *  compensate this by pushing the widened capture set of `f` into ?1.
-     *  This solves the soundness issue caused by the ill-formness of ?1.
-     */
-    private def healTypeParam(tree: Tree)(using Context): Unit =
-      val checker = new TypeTraverser:
-        private def isAllowed(ref: CaptureRef): Boolean = ref match
-          case ref: TermParamRef => allowed.contains(ref)
-          case _ => true
-
-        // Widen the given term parameter refs x₁ : C₁ S₁ , ⋯ , xₙ : Cₙ Sₙ to their capture sets C₁ , ⋯ , Cₙ.
-        //
-        // If in these capture sets there are any capture references that are term parameter references we should avoid,
-        // we will widen them recursively.
-        private def widenParamRefs(refs: List[TermParamRef]): List[CaptureSet] =
-          @scala.annotation.tailrec
-          def recur(todos: List[TermParamRef], acc: List[CaptureSet]): List[CaptureSet] =
-            todos match
-              case Nil => acc
-              case ref :: rem =>
-                val cs = ref.captureSetOfInfo
-                val nextAcc = cs.filter(isAllowed(_)) :: acc
-                val nextRem: List[TermParamRef] = (cs.elems.toList.filter(!isAllowed(_)) ++ rem).asInstanceOf
-                recur(nextRem, nextAcc)
-          recur(refs, Nil)
-
-        private def healCaptureSet(cs: CaptureSet): Unit =
-          val toInclude = widenParamRefs(cs.elems.toList.filter(!isAllowed(_)).asInstanceOf)
-          toInclude.foreach(checkSubset(_, cs, tree.srcPos))
-
-        private var allowed: SimpleIdentitySet[TermParamRef] = SimpleIdentitySet.empty
-
-        def traverse(tp: Type) =
-          tp match
-            case CapturingType(parent, refs) =>
-              healCaptureSet(refs)
-              traverse(parent)
-            case tp @ RefinedType(parent, rname, rinfo: MethodType) if defn.isFunctionType(tp) =>
-              traverse(rinfo)
-            case tp: TermLambda =>
-              val saved = allowed
-              try
-                tp.paramRefs.foreach(allowed += _)
-                traverseChildren(tp)
-              finally allowed = saved
-            case _ =>
-              traverseChildren(tp)
-
-      if tree.isInstanceOf[InferredTypeTree] then
-        checker.traverse(tree.knownType)
-    end healTypeParam
-
-    /** 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.
-     *   - Check that arguments of TypeApplys and AppliedTypes conform to their bounds.
-     *   - Heal ill-formed capture sets of type parameters. See `healTypeParam`.
-     */
-    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.""".withoutDisambiguation(),
-                  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 _ =>
-
-          args.foreach(healTypeParam(_))
-        case _ =>
-      }
-      if !ctx.reporter.errorsReported then
-        // We dont report errors here 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
deleted file mode 100644
index a91831022984..000000000000
--- a/tests/pos-with-compiler-cc/dotc/cc/Setup.scala
+++ /dev/null
@@ -1,482 +0,0 @@
-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 DetachedContext) = 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 DetachedContext) = 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 DetachedContext) = 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 DetachedContext)
-  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
deleted file mode 100644
index dacbd27e0f35..000000000000
--- a/tests/pos-with-compiler-cc/dotc/cc/Synthetics.scala
+++ /dev/null
@@ -1,189 +0,0 @@
-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
deleted file mode 100644
index 51b261583feb..000000000000
--- a/tests/pos-with-compiler-cc/dotc/classpath/AggregateClassPath.scala
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
- * 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
deleted file mode 100644
index 176b6acf9c6c..000000000000
--- a/tests/pos-with-compiler-cc/dotc/classpath/ClassPath.scala
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * 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
deleted file mode 100644
index ac8b69381938..000000000000
--- a/tests/pos-with-compiler-cc/dotc/classpath/ClassPathFactory.scala
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * 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
deleted file mode 100644
index a5678970411b..000000000000
--- a/tests/pos-with-compiler-cc/dotc/classpath/DirectoryClassPath.scala
+++ /dev/null
@@ -1,313 +0,0 @@
-/*
- * 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
deleted file mode 100644
index 0f5ac16b40bf..000000000000
--- a/tests/pos-with-compiler-cc/dotc/classpath/FileUtils.scala
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * 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
deleted file mode 100644
index ea7412f15d8a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/classpath/PackageNameUtils.scala
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * 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
deleted file mode 100644
index ac80d543b539..000000000000
--- a/tests/pos-with-compiler-cc/dotc/classpath/VirtualDirectoryClassPath.scala
+++ /dev/null
@@ -1,55 +0,0 @@
-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
deleted file mode 100644
index 865f95551a0b..000000000000
--- a/tests/pos-with-compiler-cc/dotc/classpath/ZipAndJarFileLookupFactory.scala
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
- * 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
deleted file mode 100644
index e241feee8244..000000000000
--- a/tests/pos-with-compiler-cc/dotc/classpath/ZipArchiveFileLookup.scala
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * 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
deleted file mode 100644
index 68c900e405da..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/CliCommand.scala
+++ /dev/null
@@ -1,198 +0,0 @@
-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
deleted file mode 100644
index 2e76561c9913..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/CommandLineParser.scala
+++ /dev/null
@@ -1,125 +0,0 @@
-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
deleted file mode 100644
index 41e123472a75..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/CompilerCommand.scala
+++ /dev/null
@@ -1,26 +0,0 @@
-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
deleted file mode 100644
index 02d075c8853d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/Config.scala
+++ /dev/null
@@ -1,256 +0,0 @@
-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 reverse dependencies in constraints are correct and complete.
-   *  Can also be enabled using -Ycheck-constraint-deps.
-   */
-  inline val checkConstraintDeps = 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, show variable/variable reverse dependencies when printing constraints. */
-  inline val showConstraintDeps = true
-
-  /** 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 mapping 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
deleted file mode 100644
index 1637c9268e30..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/Feature.scala
+++ /dev/null
@@ -1,173 +0,0 @@
-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 into = experimental("into")
-
-  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`
-
-  def fewerBracesEnabled(using Context) =
-    sourceVersion.isAtLeast(`3.3`) || enabled(fewerBraces)
-
-  /** 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(em"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(em"$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
deleted file mode 100644
index 2b2f35e49451..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/JavaPlatform.scala
+++ /dev/null
@@ -1,69 +0,0 @@
-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
deleted file mode 100644
index 0411c5604768..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/OutputDirs.scala
+++ /dev/null
@@ -1,117 +0,0 @@
-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
deleted file mode 100644
index afa30e38dc2a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/PathResolver.scala
+++ /dev/null
@@ -1,268 +0,0 @@
-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
deleted file mode 100644
index 0faacf1bcebb..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/Platform.scala
+++ /dev/null
@@ -1,46 +0,0 @@
-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
deleted file mode 100644
index ecb189de9bb3..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/Printers.scala
+++ /dev/null
@@ -1,52 +0,0 @@
-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
deleted file mode 100644
index 1e9cc82112af..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/Properties.scala
+++ /dev/null
@@ -1,142 +0,0 @@
-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
deleted file mode 100644
index ae417b717ca3..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/SJSPlatform.scala
+++ /dev/null
@@ -1,35 +0,0 @@
-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 DetachedContext) 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
deleted file mode 100644
index 407171f1a0dd..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/ScalaRelease.scala
+++ /dev/null
@@ -1,21 +0,0 @@
-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
deleted file mode 100644
index 914146c3c175..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/ScalaSettings.scala
+++ /dev/null
@@ -1,347 +0,0 @@
-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 = 23
-
-  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"))
-
-  /* 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, enable, 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", "enable", "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 YcheckConstraintDeps: Setting[Boolean] = BooleanSetting("-Ycheck-constraint-deps", "Check dependency tracking in constraints (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")
-  val YlightweightLazyVals: Setting[Boolean] = BooleanSetting("-Ylightweight-lazy-vals", "Use experimental lightweight implementation of lazy vals")
-
-  /** 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
deleted file mode 100644
index 7fdf57478f1a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/ScalaVersion.scala
+++ /dev/null
@@ -1,188 +0,0 @@
-/* @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
deleted file mode 100644
index 277833afbd5d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/Settings.scala
+++ /dev/null
@@ -1,295 +0,0 @@
-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
deleted file mode 100644
index 4b9b1b247856..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/SourceVersion.scala
+++ /dev/null
@@ -1,32 +0,0 @@
-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 `3.3-migration`, `3.3`
-  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.3`
-
-  /** 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
deleted file mode 100644
index 5b79432a97e7..000000000000
--- a/tests/pos-with-compiler-cc/dotc/config/WrappedProperties.scala
+++ /dev/null
@@ -1,42 +0,0 @@
-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
deleted file mode 100644
index 2061bddb9e8a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Annotations.scala
+++ /dev/null
@@ -1,274 +0,0 @@
-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
-import annotation.retains
-
-object Annotations {
-
-  def annotClass(tree: Tree)(using Context) =
-    if (tree.symbol.isConstructor) tree.symbol.owner
-    else tree.tpe.typeSymbol
-
-  abstract class Annotation extends Showable, 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 @retains(caps.cap))(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
deleted file mode 100644
index bcaaf6794107..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Atoms.scala
+++ /dev/null
@@ -1,36 +0,0 @@
-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
deleted file mode 100644
index d166cec11573..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/CheckRealizable.scala
+++ /dev/null
@@ -1,216 +0,0 @@
-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
-import annotation.constructorOnly
-
-/** Realizability status */
-object CheckRealizable {
-
-  sealed abstract class Realizability(val msg: String) extends Pure {
-    def andAlso(other: => Realizability): Realizability =
-      if (this == Realizable) other else this
-    def mapError(f: Realizability -> Context ?-> Realizability)(using Context): 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 @constructorOnly ctx: Context)
-  extends Realizability(i" refers to nonfinal $sym")
-
-  class HasProblemBounds(name: Name, info: Type)(using @constructorOnly ctx: 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 @constructorOnly ctx: 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 @constructorOnly ctx: Context)
-  extends Realizability(i" has conflicting base types $base1 and $base2")
-
-  class HasProblemField(fld: SingleDenotation, problem: Realizability)(using @constructorOnly ctx: 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 @constructorOnly ctx: 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
deleted file mode 100644
index 1b20b75ad8ac..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Comments.scala
+++ /dev/null
@@ -1,462 +0,0 @@
-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
deleted file mode 100644
index f45e9e5217de..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Constants.scala
+++ /dev/null
@@ -1,261 +0,0 @@
-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
deleted file mode 100644
index fb87aed77c41..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Constraint.scala
+++ /dev/null
@@ -1,214 +0,0 @@
-package dotty.tools
-package dotc
-package core
-
-import Types._, Contexts._
-import printing.Showable
-import util.{SimpleIdentitySet, SimpleIdentityMap}
-
-/** 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
-
-  /** 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
-
-  /** A string that shows the reverse dependencies maintained by this constraint
-   *  (coDeps and contraDeps for OrderingConstraints).
-   */
-  def depsToString(using Context): String
-
-  /** Does the constraint restricted to variables outside `except` depend on `tv`
-   *  in the given direction `co`?
-   *  @param `co`  If true, test whether the constraint would change if the variable is made larger
-   *               otherwise, test whether the constraint would change if the variable is made smaller.
-   */
-  def dependsOn(tv: TypeVar, except: TypeVars, co: Boolean)(using Context): Boolean
-
-  /** Depending on Config settngs:
-   *   - Under `checkConstraintsNonCyclic`, check that no constrained
-   *     parameter contains itself as a bound.
-   *   - Under `checkConstraintDeps`, check hat reverse dependencies in
-   *     constraints are correct and complete.
-   */
-  def checkWellFormed()(using Context): this.type
-
-  /** 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
deleted file mode 100644
index 96e965903010..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/ConstraintHandling.scala
+++ /dev/null
@@ -1,891 +0,0 @@
-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 TypeError(
-        em"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)(using Context) =
-      (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
-
-  private def isTransparent(tp: Type, traitOnly: Boolean)(using Context): Boolean = tp match
-    case AndType(tp1, tp2) =>
-      isTransparent(tp1, traitOnly) && isTransparent(tp2, traitOnly)
-    case _ =>
-      val cls = tp.underlyingClassRef(refinementOK = false).typeSymbol
-      cls.isTransparentClass && (!traitOnly || cls.is(Trait))
-
-  /** 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 =
-      if isTransparent(tp, traitOnly = true) && !kept.contains(tp) then
-        dropped = tp :: dropped
-        defn.AnyType
-      else tp 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 tp
-        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) and
-   *      is not transparent according to `isTransparent`.
-   *   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) && !isTransparent(tpw, traitOnly = false) && (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
-        val widenedFromSingle = widenSingle(inst)
-        val widenedFromUnion = widenOr(widenedFromSingle)
-        val widened = dropTransparentTraits(widenedFromUnion, bound)
-        widenIrreducible(widened)
-
-    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 occurrences: 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
deleted file mode 100644
index d2b1246a8149..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/ConstraintRunInfo.scala
+++ /dev/null
@@ -1,23 +0,0 @@
-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
deleted file mode 100644
index 20687dc1663a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/ContextOps.scala
+++ /dev/null
@@ -1,115 +0,0 @@
-package dotty.tools.dotc
-package core
-
-import Contexts._, Symbols._, Types._, Flags._
-import Denotations._, SymDenotations._
-import Names.Name, StdNames.nme
-import ast.untpd
-import caps.unsafe.unsafeBoxFunArg
-
-/** 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(((ctx: Context) => ctx.owner != sym).unsafeBoxFunArg)
-        .dropWhile(((ctx: Context) => ctx.owner == sym).unsafeBoxFunArg)
-        .next()
-    }
-
-    /** A new context for the interior of a class */
-    def inClassContext(selfInfo: TypeOrSymbol): Context =
-      inline def op(using Context): Context =
-        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
-      op(using ctx)
-
-    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
deleted file mode 100644
index a2389a28e941..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Contexts.scala
+++ /dev/null
@@ -1,1041 +0,0 @@
-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 compiletime.uninitialized
-
-import annotation.internal.sharable
-import annotation.retains
-
-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 {
-
-  //@sharable var nextId = 0
-
-  private val (compilerCallbackLoc, store1) = Store.empty.newLocation[CompilerCallback]()
-  private val (sbtCallbackLoc,      store2) = store1.newLocation[AnalysisCallback]()
-  private val (printerFnLoc,        store3) = store2.newLocation[DetachedContext -> 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)
-
-  inline def inDetachedContext[T](inline op: DetachedContext ?-> T)(using ctx: Context): T =
-    op(using ctx.detach)
-
-  type Context = ContextCls @retains(caps.cap)
-
-  /** 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 ContextCls(val base: ContextBase) {
-
-    //val id = nextId
-    //nextId += 1
-    //assert(id != 35599)
-
-    protected given Context = this
-
-    def outer: ContextCls @retains(this)
-    def period: Period
-    def mode: Mode
-    def owner: Symbol
-    def tree: Tree[?]
-    def scope: Scope
-    def typerState: TyperState
-    def gadt: GadtConstraint
-    def searchHistory: SearchHistory
-    def source: SourceFile
-
-    /** All outer contexts, ending in `base.initialCtx` and then `NoContext` */
-    def outersIterator: Iterator[ContextCls @retains(this)]
-
-    /** A map in which more contextual properties can be stored
-     *  Typically used for attributes that are read and written only in special situations.
-     */
-    def moreProperties: Map[Key[Any], Any]
-
-    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.
-     */
-    def 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: DetachedContext -> Printer = store(printerFnLoc)
-
-    /** A function creating a printer */
-    def printer: Printer =
-      val pr = printerFn(detach)
-      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 */
-    private 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)(detach)
-        }
-      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)
-
-    /** AbstractFile 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(em"invalid file path: ${ex.getMessage}")
-            NoAbstractFile
-
-    /** AbstractFile with given path, memoized */
-    def getFile(name: String): AbstractFile = getFile(name.toTermName)
-
-    final def withPhase(phase: Phase): Context = ctx.fresh.setPhase(phase.id)
-    final def withPhase(pid: PhaseId): Context = ctx.fresh.setPhase(pid)
-
-    private var related: SimpleIdentityMap[SourceFile, DetachedContext] | Null = null
-
-    private def lookup(key: SourceFile): DetachedContext | Null =
-      util.Stats.record("Context.related.lookup")
-      if related == null then
-        related = SimpleIdentityMap.empty
-        null
-      else
-        related.nn(key)
-
-    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))
-          val dctx = ctx2.detach
-          ctx1 = dctx
-          related = related.nn.updated(source, dctx)
-        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] = uninitialized
-
-    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 = detach.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 = detach.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[?], 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
-
-    /** 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 =
-      //if true then
-      //  outersIterator.map { ctx =>
-      //    i"${ctx.id} / ${ctx.owner} / ${ctx.moreProperties.valuesIterator.map(_.getClass).toList.mkString(", ")}"
-      //  }.mkString("\n")
-      //else
-        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()
-
-    protected def resetCaches(): Unit =
-      implicitsCache = null
-      related = null
-
-    /** Reuse this context as a fresh context nested inside `outer` */
-    def reuseIn(outer: Context): this.type
-
-    def detach: DetachedContext
-  }
-
-  object detached:
-    opaque type DetachedContext <: ContextCls = ContextCls
-    inline def apply(c: ContextCls): DetachedContext = c
-
-  type DetachedContext = detached.DetachedContext
-
-  /** 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 ContextCls(base) { thiscontext =>
-
-    private var _outer: DetachedContext = uninitialized
-    def outer: DetachedContext = _outer
-
-    def outersIterator: Iterator[ContextCls] = new Iterator[ContextCls] {
-      var current: ContextCls = thiscontext
-      def hasNext = current != NoContext
-      def next = { val c = current; current = current.outer; c }
-    }
-
-    private var _period: Period = uninitialized
-    final def period: Period = _period
-
-    private var _mode: Mode = uninitialized
-    final def mode: Mode = _mode
-
-    private var _owner: Symbol = uninitialized
-    final def owner: Symbol = _owner
-
-    private var _tree: Tree[?]= _
-    final def tree: Tree[?] = _tree
-
-    private var _scope: Scope = uninitialized
-    final def scope: Scope = _scope
-
-    private var _typerState: TyperState = uninitialized
-    final def typerState: TyperState = _typerState
-
-    private var _gadt: GadtConstraint = uninitialized
-    final def gadt: GadtConstraint = _gadt
-
-    private var _searchHistory: SearchHistory = uninitialized
-    final def searchHistory: SearchHistory = _searchHistory
-
-    private var _source: SourceFile = uninitialized
-    final def source: SourceFile = _source
-
-    private var _moreProperties: Map[Key[Any], Any] = uninitialized
-    final def moreProperties: Map[Key[Any], Any] = _moreProperties
-
-    private var _store: Store = uninitialized
-    final def store: Store = _store
-
-   /** 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.asInstanceOf[DetachedContext]
-      _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 =
-      resetCaches()
-      init(outer, outer)
-
-    def detach: DetachedContext = detached(this)
-
-    def setPeriod(period: Period): this.type =
-      util.Stats.record("Context.setPeriod")
-      assert(period.firstPhaseId == period.lastPhaseId, period)
-      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[?]): 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 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: DetachedContext -> 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)
-  }
-
-  object FreshContext:
-    /** Defines an initial context with given context base and possible settings. */
-    def initial(base: ContextBase, settingsGroup: SettingGroup): Context =
-      val c = new FreshContext(base)
-      c._outer = NoContext
-      c._period = InitialPeriod
-      c._mode = Mode.None
-      c._typerState = TyperState.initialState()
-      c._owner = NoSymbol
-      c._tree = untpd.EmptyTree
-      c._moreProperties = Map(MessageLimiter -> DefaultMessageLimiter())
-      c._scope = EmptyScope
-      c._source = NoSource
-      c._store = initialStore
-          .updated(settingsStateLoc, settingsGroup.defaultState)
-          .updated(notNullInfosLoc, Nil)
-          .updated(compilationUnitLoc, NoCompilationUnit)
-      c._searchHistory = new SearchRoot
-      c._gadt = GadtConstraint.empty
-      c
-  end FreshContext
-
-  given detachedCtx(using c: Context): DetachedContext = c.detach
-
-  given ops: AnyRef with
-    extension (c: Context)
-      def addNotNullInfo(info: NotNullInfo): Context =
-        c.withNotNullInfos(c.notNullInfos.extendWith(info))
-
-      def addNotNullRefs(refs: Set[TermRef]): Context =
-        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
-
-  @sharable val NoContext: DetachedContext = detached(
-    new FreshContext((null: ContextBase | Null).uncheckedNN) {
-      override val implicits: ContextualImplicits = new ContextualImplicits(Nil, null, false)(detached(this: @unchecked))
-      setSource(NoSource)
-    }
-  )
-
-  /** 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 = FreshContext.initial(this: @unchecked, settings)
-
-    /** The platform, initialized by `initPlatform()`. */
-    private var _platform: Platform | Null = uninitialized
-
-    /** 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]] = uninitialized
-
-    /** Phases by id */
-    private[dotc] var phases: Array[Phase] = uninitialized
-
-    /** 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] = uninitialized
-
-    private[core] var denotTransformers: Array[DenotTransformer] = uninitialized
-
-    /** 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) = uninitialized
-
-    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
deleted file mode 100644
index f9844c6eaab6..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Decorators.scala
+++ /dev/null
@@ -1,322 +0,0 @@
-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
-import annotation.retains
-
-/** This object provides useful extension methods 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
-
-  /** Convert lazy string to message. To be with caution, since no message-defined
-   *  formatting will be done on the string.
-   */
-  extension (str: -> String)
-    def toMessage: Message = NoExplanation(str)(using NoContext)
-
-  /** 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.
-   */
-  extension [T](xs: List[T])
-    final def collectCC[U](pf: PartialFunction[T, U] @retains(caps.cap)): List[U] =
-      xs.collect(pf.asInstanceOf)
-
-    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 setUnion (ys: List[T]): List[T] = xs ::: ys.filterNot(xs 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 [T](xs: Seq[T])
-    final def collectCC[U](pf: PartialFunction[T, U] @retains(caps.cap)): Seq[U] =
-      xs.collect(pf.asInstanceOf)
-
-  extension [A, B](f: PartialFunction[A, B] @retains(caps.cap))
-    def orElseCC(g: PartialFunction[A, B] @retains(caps.cap)): PartialFunction[A, B] @retains(f, g) =
-      f.orElse(g.asInstanceOf).asInstanceOf
-
-  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.message
-              case _ => ex.getMessage
-            s"[cannot display due to $msg, raw string = $x]"
-      case _ => String.valueOf(x).nn
-
-    /** Returns the simple class name of `x`. */
-    def className: String = getClass.getSimpleName.nn
-
-  extension [T](x: T)
-    def assertingErrorsReported(using Context): T = {
-      assert(ctx.reporter.errorsReported)
-      x
-    }
-    def assertingErrorsReported(msg: Message)(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)
-
-    /** Interpolator yielding an error message, which undergoes
-     *  the formatting defined in Message.
-     */
-    def em(args: Shown*)(using Context): NoExplanation =
-      NoExplanation(i(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
deleted file mode 100644
index 8faf208e36d0..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Definitions.scala
+++ /dev/null
@@ -1,2433 +0,0 @@
-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: DetachedContext = _
-  private given currentContext[Dummy_so_its_a_def]: DetachedContext = 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))
-
-  @tu lazy val IntoType: TypeSymbol = enterAliasType(tpnme.INTO, HKTypeLambda(TypeBounds.empty :: Nil)(_.paramRefs(0)))
-
-  // 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 MethodHandleClass: ClassSymbol        = requiredClass("java.lang.invoke.MethodHandle")
-  @tu lazy val MethodHandlesLookupClass: ClassSymbol = requiredClass("java.lang.invoke.MethodHandles.Lookup")
-  @tu lazy val VarHandleClass: ClassSymbol           = requiredClass("java.lang.invoke.VarHandle")
-
-  @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 StaticAnnotationClass: ClassSymbol = requiredClass("scala.annotation.StaticAnnotation")
-  @tu lazy val RefiningAnnotationClass: ClassSymbol = requiredClass("scala.annotation.RefiningAnnotation")
-
-  // Annotation classes
-  @tu lazy val AllowConversionsAnnot: ClassSymbol = requiredClass("scala.annotation.allowConversions")
-  @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 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)
-
-  /** 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)
-
-  @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 assumedTransparentNames: Map[Name, Set[Symbol]] =
-    // add these for now, until we had a chance to retrofit 2.13 stdlib
-    // we should do a more through sweep through it then.
-    val strs = Map(
-      "Any" -> Set("scala"),
-      "AnyVal" -> Set("scala"),
-      "Matchable" -> Set("scala"),
-      "Product" -> Set("scala"),
-      "Object" -> Set("java.lang"),
-      "Comparable" -> Set("java.lang"),
-      "Serializable" -> Set("java.io"),
-      "BitSetOps" -> Set("scala.collection"),
-      "IndexedSeqOps" -> Set("scala.collection", "scala.collection.mutable", "scala.collection.immutable"),
-      "IterableOnceOps" -> Set("scala.collection"),
-      "IterableOps" -> Set("scala.collection"),
-      "LinearSeqOps" -> Set("scala.collection", "scala.collection.immutable"),
-      "MapOps" -> Set("scala.collection", "scala.collection.mutable", "scala.collection.immutable"),
-      "SeqOps" -> Set("scala.collection", "scala.collection.mutable", "scala.collection.immutable"),
-      "SetOps" -> Set("scala.collection", "scala.collection.mutable", "scala.collection.immutable"),
-      "SortedMapOps" -> Set("scala.collection", "scala.collection.mutable", "scala.collection.immutable"),
-      "SortedOps" -> Set("scala.collection"),
-      "SortedSetOps" -> Set("scala.collection", "scala.collection.mutable", "scala.collection.immutable"),
-      "StrictOptimizedIterableOps" -> Set("scala.collection"),
-      "StrictOptimizedLinearSeqOps" -> Set("scala.collection"),
-      "StrictOptimizedMapOps" -> Set("scala.collection", "scala.collection.immutable"),
-      "StrictOptimizedSeqOps" -> Set("scala.collection", "scala.collection.immutable"),
-      "StrictOptimizedSetOps" -> Set("scala.collection", "scala.collection.immutable"),
-      "StrictOptimizedSortedMapOps" -> Set("scala.collection", "scala.collection.immutable"),
-      "StrictOptimizedSortedSetOps" -> Set("scala.collection", "scala.collection.immutable"),
-      "ArrayDequeOps" -> Set("scala.collection.mutable"),
-      "DefaultSerializable" -> Set("scala.collection.generic"),
-      "IsIterable" -> Set("scala.collection.generic"),
-      "IsIterableLowPriority" -> Set("scala.collection.generic"),
-      "IsIterableOnce" -> Set("scala.collection.generic"),
-      "IsIterableOnceLowPriority" -> Set("scala.collection.generic"),
-      "IsMap" -> Set("scala.collection.generic"),
-      "IsSeq" -> Set("scala.collection.generic"))
-    strs.map { case (simple, pkgs) => (
-        simple.toTypeName,
-        pkgs.map(pkg => staticRef(pkg.toTermName, isPackage = true).symbol.moduleClass)
-      )
-    }
-
-  def isAssumedTransparent(sym: Symbol): Boolean =
-    assumedTransparentNames.get(sym.name) match
-      case Some(pkgs) => pkgs.contains(sym.owner)
-      case none => false
-
-  // ----- 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,
-      IntoType,
-      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 ctx: DetachedContext): 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
-  }
-
-  /** Definitions used in Lazy Vals implementation */
-  val LazyValsModuleName = "scala.runtime.LazyVals"
-  @tu lazy val LazyValsModule = requiredModule(LazyValsModuleName)
-  @tu lazy val LazyValsWaitingState = requiredClass(s"$LazyValsModuleName.Waiting")
-  @tu lazy val LazyValsControlState = requiredClass(s"$LazyValsModuleName.LazyValControlState")
-
-  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
deleted file mode 100644
index 6690cae3a142..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/DenotTransformers.scala
+++ /dev/null
@@ -1,82 +0,0 @@
-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
deleted file mode 100644
index 9db285975a0a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Denotations.scala
+++ /dev/null
@@ -1,1376 +0,0 @@
-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 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 then em"$site does not have a member $kind $name$argStr"
-            else em"missing: $kind $name$argStr"
-          throw 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 =
-      inDetachedContext:
-        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 DetachedContext) 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 DetachedContext) 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 DetachedContext) 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
deleted file mode 100644
index f23dce020f10..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Flags.scala
+++ /dev/null
@@ -1,612 +0,0 @@
-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 / a Java annotation */
-  val (_, JavaVarargs @ _, JavaAnnotation @ _) = newFlags(37, "<varargs>", "<java-annotation>")
-
-  /** Symbol is a Java default method */
-  val (_, DefaultMethod @ _, _) = newFlags(38, "<defaultmethod>")
-
-  /** Symbol is a transparent inline method or trait */
-  val (Transparent @ _, _, TransparentType @ _) = 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, JavaAnnotation, 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
-}
diff --git a/tests/pos-with-compiler-cc/dotc/core/GadtConstraint.scala b/tests/pos-with-compiler-cc/dotc/core/GadtConstraint.scala
deleted file mode 100644
index fcf1215c604f..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/GadtConstraint.scala
+++ /dev/null
@@ -1,267 +0,0 @@
-package dotty.tools
-package dotc
-package core
-
-import Decorators._
-import Contexts._
-import Types._
-import Symbols._
-import util.{SimpleIdentitySet, SimpleIdentityMap}
-import collection.mutable
-import printing._
-import annotation.retains
-
-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)(using null)
-  }
-
-  /** 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 @retains(caps.cap) | 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] @retains(caps.cap) | 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
deleted file mode 100644
index 79da5f1dcd6f..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Hashable.scala
+++ /dev/null
@@ -1,126 +0,0 @@
-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
deleted file mode 100644
index 60fc4a4274e0..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/JavaNullInterop.scala
+++ /dev/null
@@ -1,149 +0,0 @@
-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
deleted file mode 100644
index d8f41ef99b11..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/MacroClassLoader.scala
+++ /dev/null
@@ -1,29 +0,0 @@
-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
deleted file mode 100644
index 062ddd5e846c..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/MatchTypeTrace.scala
+++ /dev/null
@@ -1,136 +0,0 @@
-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
deleted file mode 100644
index 40a45b9f4678..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Mode.scala
+++ /dev/null
@@ -1,144 +0,0 @@
-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
deleted file mode 100644
index 07c69afdaf24..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/NameKinds.scala
+++ /dev/null
@@ -1,414 +0,0 @@
-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 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 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
deleted file mode 100644
index 7c1073852681..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/NameOps.scala
+++ /dev/null
@@ -1,400 +0,0 @@
-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
deleted file mode 100644
index 59dfaa3d437b..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/NameTags.scala
+++ /dev/null
@@ -1,68 +0,0 @@
-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
deleted file mode 100644
index c756ec242c5c..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/NamerOps.scala
+++ /dev/null
@@ -1,223 +0,0 @@
-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(em"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 DetachedContext) 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),
-        privateWithin = cls.privateWithin,
-        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
deleted file mode 100644
index d1eba69c57a0..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Names.scala
+++ /dev/null
@@ -1,694 +0,0 @@
-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 Decorators.orElseCC
-
-import scala.annotation.internal.sharable
-import annotation.retains
-
-object Names {
-  import NameKinds._
-
-  /** Things that can be turned into names with `toTermName` and `toTypeName`.
-   *  Decorators 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, 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] @retains(caps.cap)): ThisName
-
-    /** Same as replace, but does not stop at DerivedNames with infos of kind QualifiedInfo. */
-    def replaceDeep(f: PartialFunction[Name, Name] @retains(caps.cap)): ThisName =
-      replace(f.orElseCC {
-        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] @retains(caps.cap)): 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] @retains(caps.cap)): 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] @retains(caps.cap)): 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
deleted file mode 100644
index e18271772ff1..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/NullOpsDecorator.scala
+++ /dev/null
@@ -1,60 +0,0 @@
-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
deleted file mode 100644
index 0bf798c00540..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/OrderingConstraint.scala
+++ /dev/null
@@ -1,1007 +0,0 @@
-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 {
-
-  /** If true, use reverse dependencies in `replace` to avoid checking the bounds
-   *  of all parameters in the constraint. This can speed things up, but there are some
-   *  rare corner cases where reverse dependencies miss a parameter. Specifically,
-   *  if a constraint contains a free reference to TypeParam P and afterwards the
-   *  same P is added as a bound variable to the constraint, a backwards link would
-   *  then become necessary at this point but is missing. This causes two CB projects
-   *  to fail when reverse dependencies are checked (parboiled2 and perspective).
-   *  In these rare cases `replace` could behave differently when optimized. However,
-   *  no deviation was found in the two projects. It is not clear what the "right"
-   *  behavior of `replace` should be in these cases. Normally, PolyTypes added
-   *  to constraints are supposed to be fresh, so that would mean that the behavior
-   *  with optimizeReplace = true would be correct. But the previous behavior without
-   *  reverse dependency checking corresponds to `optimizeReplace = false`. This behavior
-   *  makes sense if we assume that the added polytype was simply added too late, so we
-   *  want to establish the link between newly bound variable and pre-existing reference.
-   */
-  private final val optimizeReplace = true
-
-  private type ArrayValuedMap[T] = SimpleIdentityMap[TypeLambda, Array[T]]
-
-  /** The type of `OrderingConstraint#boundsMap` */
-  private type ParamBounds = ArrayValuedMap[Type]
-
-  /** The type of `OrderingConstraint#lowerMap`, `OrderingConstraint#upperMap` */
-  private type ParamOrdering = ArrayValuedMap[List[TypeParamRef]]
-
-  /** A lens for updating a single entry array in one of the three constraint maps */
-  private 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` then `current` 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)
-  }
-
-  private 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 =
-      c.newConstraint(boundsMap = c.boundsMap.updated(poly, entries))
-    def initial = NoType
-  }
-
-  private 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 =
-      c.newConstraint(lowerMap = c.lowerMap.updated(poly, entries))
-    def initial = Nil
-  }
-
-  private 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 =
-      c.newConstraint(upperMap = c.upperMap.updated(poly, entries))
-    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 {
-  thisConstraint =>
-
-  import UnificationDirection.*
-
-  type This = OrderingConstraint
-
-  /** A new constraint with given maps and given set of hard typevars */
-  def newConstraint( // !!! Dotty problem: Making newConstraint `private` causes -Ytest-pickler failure.
-    boundsMap: ParamBounds = this.boundsMap,
-    lowerMap: ParamOrdering = this.lowerMap,
-    upperMap: ParamOrdering = this.upperMap,
-    hardVars: TypeVars = this.hardVars)(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.coDeps = this.coDeps
-        result.contraDeps = this.contraDeps
-        result
-
-// ----------- 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
-
-// ------------- Type parameter dependencies ----------------------------------------
-
-  private type ReverseDeps = SimpleIdentityMap[TypeParamRef, SimpleIdentitySet[TypeParamRef]]
-
-  /** A map that associates type parameters of this constraint with all other type
-   *  parameters that refer to them in their bounds covariantly, such that, if the
-   *  type parameter is instantiated to a larger type, the constraint would be narrowed
-   *  (i.e. solution set changes other than simply being made larger).
-   */
-  private var coDeps: ReverseDeps = SimpleIdentityMap.empty
-
-  /** A map that associates type parameters of this constraint with all other type
-   *  parameters that refer to them in their bounds covariantly, such that, if the
-   *  type parameter is instantiated to a smaller type, the constraint would be narrowed.
-   *  (i.e. solution set changes other than simply being made larger).
-   */
-  private var contraDeps: ReverseDeps = SimpleIdentityMap.empty
-
-  /** Null-safe indexing */
-  extension (deps: ReverseDeps) def at(param: TypeParamRef): SimpleIdentitySet[TypeParamRef] =
-    val result = deps(param)
-    if null == result  // swapped operand order important since `==` is overloaded in `SimpleIdentitySet`
-    then SimpleIdentitySet.empty
-    else result
-
-  override def dependsOn(tv: TypeVar, except: TypeVars, co: Boolean)(using Context): Boolean =
-    def origin(tv: TypeVar) =
-      assert(!instType(tv).exists)
-      tv.origin
-    val param = origin(tv)
-    val excluded = except.map(origin)
-    val qualifies: TypeParamRef => Boolean = !excluded.contains(_)
-    def test(deps: ReverseDeps, lens: ConstraintLens[List[TypeParamRef]]) =
-      deps.at(param).exists(qualifies)
-      || lens(this, tv.origin.binder, tv.origin.paramNum).exists(qualifies)
-    if co then test(coDeps, upperLens) else test(contraDeps, lowerLens)
-
-  /** Modify traversals in two respects:
-   *   - when encountering an application C[Ts], where C is a type variable or parameter
-   *     that has an instantiation in this constraint, assume the type parameters of
-   *     the instantiation instead of the type parameters of C when traversing the
-   *     arguments Ts. That can make a difference for the variance in which an argument
-   *     is traversed. Example constraint:
-   *
-   *         constrained types: C[X], A
-   *         A >: C[B]
-   *         C := Option
-   *
-   *     Here, B is traversed with variance +1 instead of 0. Test case: pos/t3152.scala
-   *
-   *   - When typing a prefx, don't avoid negative variances. This matters only for the
-   *     corner case where a parameter is instantiated to Nothing (see comment in
-   *     TypeAccumulator#applyToPrefix). When determining instantiation directions in
-   *     interpolations (which is what dependency variances are for), it can be ignored.
-   */
-  private trait ConstraintAwareTraversal[T] extends TypeAccumulator[T]:
-
-    /** Does `param` have bounds in the current constraint? */
-    protected def hasBounds(param: TypeParamRef): Boolean = entry(param).isInstanceOf[TypeBounds]
-
-    override def tyconTypeParams(tp: AppliedType)(using Context): List[ParamInfo] =
-      def tparams(tycon: Type): List[ParamInfo] = tycon match
-        case tycon: TypeVar if !tycon.inst.exists => tparams(tycon.origin)
-        case tycon: TypeParamRef if !hasBounds(tycon) =>
-          val entryParams = entry(tycon).typeParams
-          if entryParams.nonEmpty then entryParams
-          else tp.tyconTypeParams
-        case _ => tp.tyconTypeParams
-      tparams(tp.tycon)
-
-    override def applyToPrefix(x: T, tp: NamedType): T =
-      this(x, tp.prefix)
-  end ConstraintAwareTraversal
-
-  /** A type traverser that adjust dependencies originating from a given type
-   *  @param ignoreBinding  if not null, a parameter that is assumed to be still uninstantiated.
-   *                        This is necessary to handle replacements.
-   */
-  private class Adjuster(srcParam: TypeParamRef, ignoreBinding: TypeParamRef | Null)(using Context)
-  extends TypeTraverser, ConstraintAwareTraversal[Unit]:
-
-    var add: Boolean = compiletime.uninitialized
-    val seen = util.HashSet[LazyRef]()
-
-    override protected def hasBounds(param: TypeParamRef) =
-      (param eq ignoreBinding) || super.hasBounds(param)
-
-    def update(deps: ReverseDeps, referenced: TypeParamRef): ReverseDeps =
-      val prev = deps.at(referenced)
-      val newSet = if add then prev + srcParam else prev - srcParam
-      if newSet.isEmpty then deps.remove(referenced)
-      else deps.updated(referenced, newSet)
-
-    def traverse(t: Type) = t match
-      case param: TypeParamRef =>
-        if hasBounds(param) then
-          if variance >= 0 then coDeps = update(coDeps, param)
-          if variance <= 0 then contraDeps = update(contraDeps, param)
-        else
-          traverse(entry(param))
-      case tp: LazyRef =>
-        if !seen.contains(tp) then
-          seen += tp
-          traverse(tp.ref)
-      case _ => traverseChildren(t)
-  end Adjuster
-
-  /** Adjust dependencies to account for the delta of previous entry `prevEntry`
-   *  and the new bound `entry` for the type parameter `srcParam`.
-   */
-  def adjustDeps(entry: Type | Null, prevEntry: Type | Null, srcParam: TypeParamRef, ignoreBinding: TypeParamRef | Null = null)(using Context): this.type =
-    val adjuster = new Adjuster(srcParam, ignoreBinding)
-
-    /** Adjust reverse dependencies of all type parameters referenced by `bound`
-     *  @param  isLower `bound` is a lower bound
-     *  @param  add     if true, add referenced variables to dependencoes, otherwise drop them.
-     */
-    def adjustReferenced(bound: Type, isLower: Boolean, add: Boolean) =
-      adjuster.variance = if isLower then 1 else -1
-      adjuster.add = add
-      adjuster.seen.clear()
-      adjuster.traverse(bound)
-
-    /** Use an optimized strategy to adjust dependencies to account for the delta
-     *  of previous bound `prevBound` and new bound `bound`: If `prevBound` is some
-     *  and/or prefix of `bound`, and `baseCase` is true, just add the new parts of `bound`.
-     *  @param  isLower `bound` and `prevBound` are lower bounds
-     *  @return true iff the delta strategy succeeded, false if it failed in which case
-     *          the constraint is left unchanged.
-     */
-    def adjustDelta(bound: Type, prevBound: Type, isLower: Boolean, baseCase: => Boolean): Boolean =
-      if bound eq prevBound then
-        baseCase
-      else bound match
-        case bound: AndOrType =>
-          adjustDelta(bound.tp1, prevBound, isLower, baseCase) && {
-            adjustReferenced(bound.tp2, isLower, add = true)
-            true
-          }
-        case _ => false
-
-    /** Add or remove depenencies referenced in `bounds`.
-     *  @param add   if true, dependecies are added, otherwise they are removed
-     */
-    def adjustBounds(bounds: TypeBounds, add: Boolean) =
-      adjustReferenced(bounds.lo, isLower = true, add)
-      adjustReferenced(bounds.hi, isLower = false, add)
-
-    entry match
-      case entry @ TypeBounds(lo, hi) =>
-        prevEntry match
-          case prevEntry @ TypeBounds(plo, phi) =>
-            if !adjustDelta(lo, plo, isLower = true,
-                  adjustDelta(hi, phi, isLower = false, true))
-            then
-              adjustBounds(prevEntry, add = false)
-              adjustBounds(entry, add = true)
-          case _ =>
-            adjustBounds(entry, add = true)
-      case _ =>
-        prevEntry match
-          case prevEntry: TypeBounds =>
-            adjustBounds(prevEntry, add = false)
-          case _ =>
-        dropDeps(srcParam) // srcParam is instantiated, so its dependencies can be dropped
-    this
-  end adjustDeps
-
-  /** Adjust dependencies to account for adding or dropping all `entries` associated
-   *  with `poly`.
-   *  @param add   if true, entries is added, otherwise it is dropped
-   */
-  def adjustDeps(poly: TypeLambda, entries: Array[Type], add: Boolean)(using Context): this.type =
-    for n <- 0 until paramCount(entries) do
-      if add
-      then adjustDeps(entries(n), NoType, poly.paramRefs(n))
-      else adjustDeps(NoType, entries(n), poly.paramRefs(n))
-    this
-
-  /** Remove all reverse dependencies of `param` */
-  def dropDeps(param: TypeParamRef)(using Context): Unit =
-    coDeps = coDeps.remove(param)
-    contraDeps = contraDeps.remove(param)
-
-  /** A string representing the two dependency maps */
-  def depsToString(using Context): String =
-    def depsStr(deps: ReverseDeps): String =
-      def depStr(param: TypeParamRef) = i"$param --> ${deps.at(param).toList}%, %"
-      if deps.isEmpty then "" else i"\n     ${deps.toList.map((k, v) => depStr(k))}%\n     %"
-    i" co-deps:${depsStr(coDeps)}\n contra-deps:${depsStr(contraDeps)}\n"
-
-// ---------- 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 = this.boundsMap.updated(poly, entries1))
-      .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 = boundsLens.update(this, current, param, stripped)
-      while todos.nonEmpty do
-        current = todos.head.unsafeUnbox(current, param)
-        todos.dropInPlace(1)
-      i += 1
-    }
-    current.adjustDeps(poly, current.boundsMap(poly).nn, add = true)
-      .checkWellFormed()
-  }
-
-// ---------- 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).setUnion(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, newEntry: Type)(using Context): This = {
-    if Config.checkNoWildcardsInConstraint then assert(!newEntry.containsWildcardTypes)
-    val oldEntry = current.entry(param)
-    var current1 = boundsLens.update(this, current, param, newEntry)
-      .adjustDeps(newEntry, oldEntry, param)
-    newEntry 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)).checkWellFormed()
-
-  def addLess(param1: TypeParamRef, param2: TypeParamRef, direction: UnificationDirection)(using Context): This =
-    order(this, param1, param2, direction).checkWellFormed()
-
-// ---------- 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.checkWellFormed()
-    else
-      assert(replacement.isValueTypeOrLambda)
-
-      val replacedTypeVar = typeVarOfParam(param)
-      //println(i"replace $param with $replacement in $this")
-
-      def mapReplacedTypeVarTo(to: Type) = new TypeMap:
-        override def apply(t: Type): Type =
-          if (t eq replacedTypeVar) && t.exists then to else mapOver(t)
-
-      val coDepsOfParam = coDeps.at(param)
-      val contraDepsOfParam = contraDeps.at(param)
-
-      var current = updateEntry(this, param, replacement)
-        // Need to update param early to avoid infinite recursion on instantiation.
-        // See i16311.scala for a test case. On the other hand, for the purposes of
-        // dependency adjustment, we need to pretend that `param` is still unbound.
-        // We achieve that by passing a `ignoreBinding = param` to `adjustDeps` below.
-
-      def removeParamFrom(ps: List[TypeParamRef]) =
-        ps.filterConserve(param ne _)
-
-      for lo <- lower(param) do
-        current = upperLens.map(this, current, lo, removeParamFrom)
-      for hi <- upper(param) do
-        current = lowerLens.map(this, current, hi, removeParamFrom)
-
-      def replaceParamIn(other: TypeParamRef) =
-        val oldEntry = current.entry(other)
-        val newEntry = current.ensureNonCyclic(other, oldEntry.substParam(param, replacement))
-        current = boundsLens.update(this, current, other, newEntry)
-        var oldDepEntry = oldEntry
-        var newDepEntry = newEntry
-        replacedTypeVar match
-          case tvar: TypeVar =>
-            if tvar.inst.exists // `isInstantiated` would use ctx.typerState.constraint rather than the current constraint
-            then
-              // If the type variable has been instantiated, we need to forget about
-              // the instantiation for old dependencies.
-              // I.e. to find out what the old entry was, we should not follow
-              // the newly instantiated type variable but assume the type variable's origin `param`.
-              // An example where this happens is if `replace` is called from TypeVar's `instantiateWith`.
-              oldDepEntry = mapReplacedTypeVarTo(param)(oldDepEntry)
-            else
-              // If the type variable has not been instantiated, we need to replace references to it
-              // in the new entry by `replacement`. Otherwise we would get stuck in an uninstantiated
-              // type variable.
-              // An example where this happens is if `replace` is called from unify.
-              newDepEntry = mapReplacedTypeVarTo(replacement)(newDepEntry)
-          case _ =>
-        if oldDepEntry ne newDepEntry then
-          current.adjustDeps(newDepEntry, oldDepEntry, other, ignoreBinding = param)
-      end replaceParamIn
-
-      if optimizeReplace then
-        current.foreachParam { (p, i) =>
-          val other = p.paramRefs(i)
-          entry(other) match
-            case _: TypeBounds =>
-              if coDepsOfParam.contains(other) || contraDepsOfParam.contains(other) then
-                replaceParamIn(other)
-            case _ => replaceParamIn(other)
-        }
-      else
-        current.foreachParam { (p, i) =>
-          val other = p.paramRefs(i)
-          if other != param then replaceParamIn(other)
-        }
-      if isRemovable(param.binder) then current = current.remove(param.binder)
-      current.dropDeps(param)
-      current.checkWellFormed()
-  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)
-      .adjustDeps(pt, boundsMap(pt).nn, add = false)
-      .checkWellFormed()
-  }
-
-  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))
-    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.checkWellFormed()
-
-  def isHard(tv: TypeVar) = hardVars.contains(tv)
-
-  def withHard(tv: TypeVar)(using Context) =
-    newConstraint(hardVars = this.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 _ =>
-
-  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
-
-// ---------- 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 checkWellFormed()(using Context): this.type =
-
-    /** Check that each dependency A -> B in coDeps and contraDeps corresponds to
-     *  a reference to A at the right variance in the entry of B.
-     */
-    def checkBackward(deps: ReverseDeps, depsName: String, v: Int)(using Context): Unit =
-      deps.foreachBinding { (param, params) =>
-        for srcParam <- params do
-          assert(contains(srcParam) && occursAtVariance(param, v, in = entry(srcParam)),
-            i"wrong $depsName backwards reference $param -> $srcParam in $thisConstraint")
-      }
-
-    /** A type traverser that checks that all references bound in the constraint
-     *  are accounted for in coDeps and/or contraDeps.
-     */
-    def checkForward(srcParam: TypeParamRef)(using Context) =
-      new TypeTraverser with ConstraintAwareTraversal[Unit]:
-        val seen = util.HashSet[LazyRef]()
-        def traverse(t: Type): Unit = t match
-          case param: TypeParamRef if param ne srcParam =>
-            def check(deps: ReverseDeps, directDeps: List[TypeParamRef], depsName: String) =
-              assert(deps.at(param).contains(srcParam) || directDeps.contains(srcParam),
-                i"missing $depsName backwards reference $param -> $srcParam in $thisConstraint")
-            entry(param) match
-              case _: TypeBounds =>
-                if variance >= 0 then check(contraDeps, upper(param), "contra")
-                if variance <= 0 then check(coDeps, lower(param), "co")
-              case tp =>
-                traverse(tp)
-          case tp: LazyRef =>
-            if !seen.contains(tp) then
-              seen += tp
-              traverse(tp.ref)
-          case _ => traverseChildren(t)
-
-    /** Does `param` occur at variance `v` or else at variance 0 in entry `in`? */
-    def occursAtVariance(param: TypeParamRef, v: Int, in: Type)(using Context): Boolean =
-      val test = new TypeAccumulator[Boolean] with ConstraintAwareTraversal[Boolean]:
-        def apply(x: Boolean, t: Type): Boolean =
-          if x then true
-          else t match
-            case t: TypeParamRef =>
-              entry(t) match
-                case _: TypeBounds =>
-                  t == param && (variance == 0 || variance == v)
-                case e =>
-                  apply(x, e)
-            case _ =>
-              foldOver(x, t)
-      test(false, in)
-
-    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}")
-      }
-    if Config.checkConstraintDeps || ctx.settings.YcheckConstraintDeps.value then
-      checkBackward(coDeps, "co", -1)
-      checkBackward(contraDeps, "contra", +1)
-      domainParams.foreach(p => if contains(p) then checkForward(p).traverse(entry(p)))
-
-    this
-  end checkWellFormed
-
-  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 =
-      "\n bounds = " + {
-        val assocs =
-          for (param <- domainParams)
-          yield
-            s"${param.binder.paramNames(param.paramNum)}: ${entryText(entry(param))}"
-        assocs.mkString("\n")
-    }
-    val depsText =
-      "\n coDeps = " + coDeps +
-      "\n contraDeps = " + contraDeps
-    constrainedText + boundsText + depsText
-  }
-}
diff --git a/tests/pos-with-compiler-cc/dotc/core/ParamInfo.scala b/tests/pos-with-compiler-cc/dotc/core/ParamInfo.scala
deleted file mode 100644
index e88d6540e64b..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/ParamInfo.scala
+++ /dev/null
@@ -1,53 +0,0 @@
-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
deleted file mode 100644
index ff9a5cd0aed7..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/PatternTypeConstrainer.scala
+++ /dev/null
@@ -1,298 +0,0 @@
-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
deleted file mode 100644
index 44d83dcb5278..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Periods.scala
+++ /dev/null
@@ -1,143 +0,0 @@
-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
deleted file mode 100644
index 809e24b1e6ef..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Phases.scala
+++ /dev/null
@@ -1,475 +0,0 @@
-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 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
deleted file mode 100644
index f5a108a13c19..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Scopes.scala
+++ /dev/null
@@ -1,471 +0,0 @@
-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 annotation.unchecked.uncheckedCaptures
-
-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, 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 DetachedContext): 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 */
-    @uncheckedCaptures
-    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 = newScope(nestingLevel)
-    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
deleted file mode 100644
index bd744ec01846..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Signature.scala
+++ /dev/null
@@ -1,197 +0,0 @@
-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
deleted file mode 100644
index 4ca53e02a831..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/StagingContext.scala
+++ /dev/null
@@ -1,58 +0,0 @@
-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.CrossStageSafety
-
-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[CrossStageSafety.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: CrossStageSafety.QuoteTypeTags)(using Context) =
-    ctx.fresh.setProperty(TaggedTypes, taggedTypes)
-
-  def getQuoteTypeTags(using Context): CrossStageSafety.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], DetachedContext) =
-    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.detach)
-}
diff --git a/tests/pos-with-compiler-cc/dotc/core/StdNames.scala b/tests/pos-with-compiler-cc/dotc/core/StdNames.scala
deleted file mode 100644
index dff423fd0bb4..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/StdNames.scala
+++ /dev/null
@@ -1,951 +0,0 @@
-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 INTO: N                       = "<into>"
-    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 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 into: N                 = "into"
-    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
deleted file mode 100644
index 6f7e02ec4dde..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Substituters.scala
+++ /dev/null
@@ -1,228 +0,0 @@
-package dotty.tools.dotc
-package core
-
-import Types._, Symbols._, Contexts._
-import cc.CaptureSet.IdempotentCaptRefMap
-import annotation.retains
-
-/** 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 @retains(caps.cap) | 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 @retains(caps.cap) | 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 @retains(caps.cap)  | 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 @retains(caps.cap) | 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 @retains(caps.cap) | 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 @retains(caps.cap) | 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 @retains(caps.cap) | 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 @retains(caps.cap) | 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 @retains(caps.cap) | 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
deleted file mode 100644
index 5163b666fa7a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/SymDenotations.scala
+++ /dev/null
@@ -1,2989 +0,0 @@
-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)(using ctx.withOwner(symbol))
-          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(JavaAnnotation))
-
-    /** 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
-
-    // Java language spec: https://docs.oracle.com/javase/specs/jls/se11/html/jls-15.html#jls-15.12.3
-    // Scala 2 spec: https://scala-lang.org/files/archive/spec/2.13/06-expressions.html#signature-polymorphic-methods
-    def isSignaturePolymorphic(using Context): Boolean =
-      containsSignaturePolymorphic
-      && is(JavaDefined)
-      && hasAnnotation(defn.NativeAnnot)
-      && atPhase(typerPhase)(symbol.denot).paramSymss.match
-        case List(List(p)) => p.info.isRepeatedParam
-        case _             => false
-
-    def containsSignaturePolymorphic(using Context): Boolean =
-      maybeOwner == defn.MethodHandleClass
-      || maybeOwner == defn.VarHandleClass
-
-    def originalSignaturePolymorphic(using Context): Denotation =
-      if containsSignaturePolymorphic && !isSignaturePolymorphic then
-        val d = owner.info.member(name)
-        if d.symbol.isSignaturePolymorphic then d else NoDenotation
-      else NoDenotation
-
-    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 DetachedContext): 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 isTransparentClass(using Context): Boolean =
-      is(TransparentType)
-      || defn.isAssumedTransparent(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.detach.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.collectCC { 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 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) =
-              i"""Toplevel definition $name is defined in
-                 |  $chosen
-                 |and also in
-                 |  $f"""
-            if youngest.size > 1 then
-              throw TypeError(em"""${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(em"""${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 && {
-      inDetachedContext:
-        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
deleted file mode 100644
index cec7230b1e10..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/SymbolLoaders.scala
+++ /dev/null
@@ -1,450 +0,0 @@
-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.Spans.NoCoord
-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),
-      privateWithin = NoSymbol,
-      coord = NoCoord,
-      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(
-          em"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(
-          em"Resolving package/object name conflict in favor of object ${preExisting.fullName}.  The package will be inaccessible.")
-        return NoSymbol
-      }
-      else
-        throw TypeError(
-          em"""$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(em"""$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 = inDetachedContext:
-        CompilationUnit(ctx.getSource(src, scala.io.Codec(ctx.settings.encoding.value)))
-            // !cc! default arguments can't be handled
-      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 then em"i/o error while loading ${root.name}"
-        else em"""error while loading ${root.name},
-                 |$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.detach)
-    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
deleted file mode 100644
index e4fa93b5bf05..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Symbols.scala
+++ /dev/null
@@ -1,922 +0,0 @@
-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 = inDetachedContext:
-            ctx.getSource(file, scala.io.Codec(ctx.settings.encoding.value))
-            // !cc! default arguments can't be handled
-        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
deleted file mode 100644
index 62474446af03..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/TypeApplications.scala
+++ /dev/null
@@ -1,538 +0,0 @@
-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 DetachedContext) 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
deleted file mode 100644
index 0e1fc277865a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/TypeComparer.scala
+++ /dev/null
@@ -1,3265 +0,0 @@
-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
-import annotation.unchecked.uncheckedCaptures
-
-/** Provides methods to compare types.
- */
-class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling, PatternTypeConstrainer {
-  import TypeComparer._
-  Stats.record("TypeComparer")
-
-  @uncheckedCaptures
-  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.dealias.match
-              case tp2a: TypeParamRef => constraint.isLess(tp1, tp2a)
-              case tp2a: AndType => recur(tp1, tp2a)
-              case _ => false
-          || isSubTypeWhenFrozen(bounds(tp1).hi.boxed, tp2)
-          || (if canConstrain(tp1) && !approx.high then
-                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
-        || tp1.dealias.match
-            case tp1a: OrType => recur(tp1a, tp2)
-            case _ => false
-        || (if canConstrain(tp2) && !approx.low then
-              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 of a union type.
-                 )
-          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) -> Context ?-> Type,
-      original: (Type, Type) -> Context ?-> 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) -> Context ?-> Type, original: (Type, Type) -> Context ?-> Type, combineVariance: (Variance, Variance) -> Context ?-> 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.detach)
-  protected def trackingTypeComparer = TrackingTypeComparer(comparerContext.detach)
-
-  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) -> Context ?-> Type, original: (Type, Type) -> Context ?-> Type,
-      combineVariance: (Variance, Variance) -> Context ?-> 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: DetachedContext) 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).collectCC {
-                    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 TypeError(em"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: DetachedContext) 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
deleted file mode 100644
index 69a58104795f..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/TypeErasure.scala
+++ /dev/null
@@ -1,877 +0,0 @@
-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 DetachedContext): 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
deleted file mode 100644
index 43eec81467d4..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/TypeErrors.scala
+++ /dev/null
@@ -1,176 +0,0 @@
-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
-
-abstract class TypeError(using creationContext: DetachedContext) extends Exception(""), Pure:
-
-  /** Convert to message. This takes an additional Context, so that we
-   *  use the context when the message is first produced, i.e. when the TypeError
-   *  is handled. This makes a difference for CyclicErrors since we need to know
-   *  the context where the completed symbol is referenced, but the creation
-   *  context of the CyclicReference is the completion context for the symbol.
-   *  See i2887b for a test case, where we want to see
-   *  "recursive or overloaded method needs result type".
-   */
-  def toMessage(using Context): Message
-
-  /** Uses creationContext to produce the message */
-  override def getMessage: String = toMessage.message
-
-object TypeError:
-  def apply(msg: Message)(using DetachedContext) = new TypeError:
-    def toMessage(using Context) = msg
-end TypeError
-
-class MalformedType(pre: Type, denot: Denotation, absMembers: Set[Name])(using DetachedContext) extends TypeError:
-  def toMessage(using Context) = em"malformed type: $pre is not a legal prefix for $denot because it contains abstract type member${if (absMembers.size == 1) "" else "s"} ${absMembers.mkString(", ")}"
-
-class MissingType(pre: Type, name: Name)(using DetachedContext) 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 toMessage(using Context): Message =
-    if ctx.debug then printStackTrace()
-    em"""cannot resolve reference to type $pre.$name
-        |the classfile defining the type might be missing from the classpath${otherReason(pre)}"""
-end MissingType
-
-class RecursionOverflow(val op: String, details: -> String, val previous: Throwable, val weight: Int)(using DetachedContext)
-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 toMessage(using Context): Message =
-    val mostCommon = recursions.groupBy(_.op).toList.maxBy(_._2.map(_.weight).sum)._2.reverse
-    em"""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
-end RecursionOverflow
-
-/** 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: Context ?-> String, exc: Throwable, weight: Int = 1)(using Context): Nothing =
-    if (ctx.settings.YnoDecodeStacktraces.value)
-      throw exc
-    else
-      exc match {
-        case _: RecursionOverflow =>
-          inDetachedContext:
-            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 then
-            inDetachedContext:
-              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)(using DetachedContext) extends TypeError:
-  var inImplicitSearch: Boolean = false
-
-  override def toMessage(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)
-  end toMessage
-
-object CyclicReference:
-  def apply(denot: SymDenotation)(using Context): CyclicReference =
-    val ex = new CyclicReference(denot)
-    if !(ctx.mode is Mode.CheckCyclic) || ctx.settings.Ydebug.value then
-      cyclicErrors.println(s"Cyclic reference involving! $denot")
-      val sts = ex.getStackTrace.asInstanceOf[Array[StackTraceElement]]
-      for (elem <- sts take 200)
-        cyclicErrors.println(elem.toString)
-    ex
-end CyclicReference
-
diff --git a/tests/pos-with-compiler-cc/dotc/core/TypeEval.scala b/tests/pos-with-compiler-cc/dotc/core/TypeEval.scala
deleted file mode 100644
index b5684b07f181..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/TypeEval.scala
+++ /dev/null
@@ -1,247 +0,0 @@
-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 TypeError(em"${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
deleted file mode 100644
index 717da533a439..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/TypeOps.scala
+++ /dev/null
@@ -1,975 +0,0 @@
-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
-import annotation.retains
-
-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 @retains(caps.cap) | 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 */
-    def intersect(cs1: List[ClassSymbol], cs2: List[ClassSymbol]): List[ClassSymbol] =
-      val cs2AsSet = BaseClassSet(cs2)
-      cs1.filter(cs2AsSet.contains)
-
-    /** a version of Type#baseClasses that treats bottom types correctly */
-    def orBaseClasses(tp: Type): List[ClassSymbol] = tp.stripTypeVar match
-      case OrType(tp1, tp2) =>
-        if tp1.isBottomType && (tp1 frozen_<:< tp2) then orBaseClasses(tp2)
-        else if tp2.isBottomType && (tp2 frozen_<:< tp1) then orBaseClasses(tp1)
-        else intersect(orBaseClasses(tp1), orBaseClasses(tp2))
-      case _ => tp.baseClasses
-
-    /** 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 = orBaseClasses(tp)
-      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: Context ?-> 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.detach  // 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 collectCC {
-          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.detach
-              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 = {
-      // if there's a change in variance in type parameters (between subtype tp1 and supertype tp2)
-      // then we don't want to maximise the type variables in the wrong direction.
-      // For instance 15967, A[-Z] and B[Y] extends A[Y], we don't want to maximise Y to Any
-      maximizeType(protoTp1.baseType(tp2.classSymbol), NoSpan)
-      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
deleted file mode 100644
index d2df2a2aebef..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/TyperState.scala
+++ /dev/null
@@ -1,306 +0,0 @@
-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
deleted file mode 100644
index 90f2e322ac1c..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Types.scala
+++ /dev/null
@@ -1,6448 +0,0 @@
-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, threadUnsafe}
-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 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, 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] @retains(caps.cap) | 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 a parameter type that allows implicit argument converson? */
-    def isConvertibleParam(using Context): Boolean =
-      typeSymbol eq defn.IntoType
-
-    /** 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).setUnion(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 `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: OrType => tp match
-        case OrNull(tp1) =>
-          // 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.widenUnionWithoutNull
-      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 DetachedContext): 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)
-
-    /** A translation from types of original parameter ValDefs to the types
-     *  of parameters in MethodTypes.
-     *  Translates `Seq[T] @repeated` or `Array[T] @repeated` to `<repeated>[T]`.
-     *  That way, repeated arguments are made manifest without risk of dropped annotations.
-     */
-    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.cap))(using Context): T
-    def map(tm: TypeMap @retains(caps.cap))(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(NamedType.validPrefix(prefix), 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 TypeError(
-            em"""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) = {}
-      //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) =
-        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): Type = {
-      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)
-
-    def validPrefix(prefix: Type): Boolean = prefix.isValueType || (prefix eq NoPrefix)
-  }
-
-  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 computeAtoms()(using Context): Atoms =
-      if tp1.hasClassSymbol(defn.NothingClass) then tp2.atoms
-      else if tp2.hasClassSymbol(defn.NothingClass) then tp1.atoms
-      else tp1.atoms | tp2.atoms
-
-    private def computeWidenSingletons()(using Context): Type =
-      val tp1w = tp1.widenSingletons
-      val tp2w = tp2.widenSingletons
-      if ((tp1 eq tp1w) && (tp2 eq tp2w)) this else TypeComparer.lub(tp1w, tp2w, isSoft = isSoft)
-
-    private def ensureAtomsComputed()(using Context): Unit =
-      if atomsRunId != ctx.runId && !isProvisional then
-        myAtoms = computeAtoms()
-        myWidened = computeWidenSingletons()
-        atomsRunId = ctx.runId
-
-    override def atoms(using Context): Atoms =
-      ensureAtomsComputed()
-      if isProvisional then computeAtoms() else myAtoms
-
-    override def widenSingletons(using Context): Type =
-      ensureAtomsComputed()
-      if isProvisional then computeWidenSingletons() else 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] @retains(caps.cap) | 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
-     *   - add @erasedParam to erased parameters
-     *   - wrap types of parameters that have an @allowConversions annotation with Into[_]
-     */
-    def fromSymbols(params: List[Symbol], resultType: Type)(using Context): MethodType =
-      def addAnnotation(tp: Type, cls: ClassSymbol): Type = tp match
-        case ExprType(resType) => ExprType(addAnnotation(resType, cls))
-        case _ => AnnotatedType(tp, Annotation(cls))
-
-      def wrapConvertible(tp: Type) =
-        AppliedType(defn.IntoType.typeRef, tp :: Nil)
-
-      /** Add `Into[..] to the type itself and if it is a function type, to all its
-       *  curried result type(s) as well.
-       */
-      def addInto(tp: Type): Type = tp match
-        case tp @ AppliedType(tycon, args) if tycon.typeSymbol == defn.RepeatedParamClass =>
-          tp.derivedAppliedType(tycon, addInto(args.head) :: Nil)
-        case tp @ AppliedType(tycon, args) if defn.isFunctionType(tp) =>
-          wrapConvertible(tp.derivedAppliedType(tycon, args.init :+ addInto(args.last)))
-        case tp @ RefinedType(parent, rname, rinfo) if defn.isFunctionOrPolyType(tp) =>
-          wrapConvertible(tp.derivedRefinedType(parent, rname, addInto(rinfo)))
-        case tp: MethodOrPoly =>
-          tp.derivedLambdaType(resType = addInto(tp.resType))
-        case ExprType(resType) =>
-          ExprType(addInto(resType))
-        case _ =>
-          wrapConvertible(tp)
-
-      def paramInfo(param: Symbol) =
-        var paramType = param.info.annotatedToRepeated
-        if param.is(Inline) then
-          paramType = addAnnotation(paramType, defn.InlineParamAnnot)
-        if param.is(Erased) then
-          paramType = addAnnotation(paramType, defn.ErasedParamAnnot)
-        if param.hasAnnotation(defn.AllowConversionsAnnot) then
-          paramType = addInto(paramType)
-        paramType
-
-      apply(params.map(_.name.asTermName))(
-         tl => params.map(p => tl.integrate(params, paramInfo(p))),
-         tl => tl.integrate(params, resultType))
-    end fromSymbols
-
-    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] @retains(caps.cap))(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 {
-
-    /** An explanation of the cause of the failure */
-    def msg(using Context): Message
-
-    /** An explanation of the cause of the failure as a string */
-    def explanation(using Context): String = msg.message
-  }
-
-  object ErrorType:
-    def apply(m: Message)(using Context): ErrorType =
-      val et = new PreviousErrorType
-      ctx.base.errorTypeMsg(et) = m
-      et
-  end ErrorType
-
-  class PreviousErrorType extends ErrorType:
-    def msg(using Context): Message =
-      ctx.base.errorTypeMsg.get(this) match
-        case Some(m) => m
-        case None => em"error message from previous run no longer available"
-
-  object UnspecifiedErrorType extends ErrorType {
-    override def msg(using Context): Message = em"unspecified error"
-  }
-
-  /* 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)
-      }
-
-    /** The type parameters of the constructor of this applied type.
-     *  Overridden in OrderingConstraint's ConstraintAwareTraversal to take account
-     *  of instantiations in the constraint that are not yet propagated to the
-     *  instance types of type variables.
-     */
-    protected def tyconTypeParams(tp: AppliedType)(using Context): List[ParamInfo] =
-      tp.tyconTypeParams
-  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: BiTypeMap @retains(caps.cap) =>
-
-    /** 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 ctx: Context): BiTypeMap @retains(ctx) = 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(using protected val mapCtx: Context)
-  extends VariantTraversal with (Type -> Type) { thisMap: TypeMap @retains(mapCtx) =>
-
-    def detach: TypeMap =
-      mapCtx.detach
-      this.asInstanceOf[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(detach))
-      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)) // see comment of TypeAccumulator's applyToPrefix
-            derivedSelect(tp, prefix1)
-
-        case tp: AppliedType =>
-          derivedAppliedType(tp, this(tp.tycon), mapArgs(tp.args, tyconTypeParams(tp)))
-
-        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 =>
-          val mapCtx1 = mapCtx.asInstanceOf[FreshContext]
-          LazyRef { refCtx =>
-            val ref1 = tp.ref(using refCtx)
-            if refCtx.runId == mapCtx1.runId then this(ref1)
-            else // splice in new run into map context
-              val savedPeriod = mapCtx1.period
-              val savedRun = mapCtx1.run
-              mapCtx1.setPeriod(Period(refCtx.runId, mapCtx1.phaseId)).setRun(refCtx.run)
-              try this(ref1)
-              finally mapCtx1.setPeriod(savedPeriod).setRun(savedRun)
-          }
-
-        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.detach)
-
-    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 mapCtx: Context)
-  extends TypeMap { thisMap: TypeMap @retains(mapCtx) =>
-    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(using 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 mapCtx: Context)
-  extends TypeMap { thisMap: TypeMap @retains(mapCtx) =>
-
-    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, tyconTypeParams(tp)))
-              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.cap) =>
-
-    def apply(x: T, tp: Type): T
-
-    protected def applyToAnnot(x: T, annot: Annotation): T = x // don't go into annotations
-
-    /** 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`, since 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.
-     *  Overridden in OrderingConstraint's ConstraintAwareTraversal, where a
-     *  more relaxed scheme is used.
-     */
-    protected def applyToPrefix(x: T, tp: NamedType): T =
-      atVariance(variance max 0)(this(x, tp.prefix))
-
-    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), tyconTypeParams(tp), 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
deleted file mode 100644
index 4078a2b1051a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Uniques.scala
+++ /dev/null
@@ -1,92 +0,0 @@
-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
deleted file mode 100644
index 2401b43c8e17..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/Variances.scala
+++ /dev/null
@@ -1,82 +0,0 @@
-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
deleted file mode 100644
index 46581d00714e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/classfile/AbstractFileReader.scala
+++ /dev/null
@@ -1,100 +0,0 @@
-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
deleted file mode 100644
index acd7982f4fd3..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/classfile/ByteCodecs.scala
+++ /dev/null
@@ -1,224 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     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
deleted file mode 100644
index 4aa60d973264..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/classfile/ClassfileConstants.scala
+++ /dev/null
@@ -1,381 +0,0 @@
-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 JAVA_ACC_ANNOTATION => JavaAnnotation
-      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 = {
-      var res: FlagSet = baseFlags | JavaDefined
-      res = addFlag(res, jflags & JAVA_ACC_PRIVATE)
-      res = addFlag(res, jflags & JAVA_ACC_PROTECTED)
-      res = addFlag(res, jflags & JAVA_ACC_FINAL)
-      res = addFlag(res, jflags & JAVA_ACC_SYNTHETIC)
-      res = addFlag(res, jflags & JAVA_ACC_STATIC)
-      res = addFlag(res, jflags & JAVA_ACC_ENUM)
-      res = addFlag(res, jflags & JAVA_ACC_ABSTRACT)
-      res = addFlag(res, jflags & JAVA_ACC_INTERFACE)
-      res = addFlag(res, jflags & JAVA_ACC_ANNOTATION)
-      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
deleted file mode 100644
index 21140f437114..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/classfile/ClassfileParser.scala
+++ /dev/null
@@ -1,1374 +0,0 @@
-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
-import annotation.retains
-
-object ClassfileParser {
-  /** Marker trait for unpicklers that can be embedded in classfiles. */
-  trait Embedded extends Pure
-
-  /** 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)
-    }
-  }).detach
-}
-
-class ClassfileParser(
-    classfile: AbstractFile,
-    classRoot: ClassDenotation,
-    moduleRoot: ClassDenotation)(ictx: DetachedContext) {
-
-  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 DetachedContext): 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 (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.
-
-      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(em"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(em"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(em"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(em"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 && sym.name != nme.CONSTRUCTOR)
-      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: DetachedContext, 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(em"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(em"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
deleted file mode 100644
index d96bebf25fb7..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/classfile/DataReader.scala
+++ /dev/null
@@ -1,61 +0,0 @@
-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
deleted file mode 100644
index eb1649091f77..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/classfile/ReusableDataReader.scala
+++ /dev/null
@@ -1,150 +0,0 @@
-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
deleted file mode 100644
index a49e3b066c62..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/tasty/CommentPickler.scala
+++ /dev/null
@@ -1,44 +0,0 @@
-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 MemberDefs 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
deleted file mode 100644
index eb0d140df51e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/tasty/CommentUnpickler.scala
+++ /dev/null
@@ -1,35 +0,0 @@
-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
deleted file mode 100644
index b35c5c9f1acc..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/tasty/DottyUnpickler.scala
+++ /dev/null
@@ -1,74 +0,0 @@
-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
deleted file mode 100644
index 623508780325..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/tasty/NameBuffer.scala
+++ /dev/null
@@ -1,126 +0,0 @@
-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
deleted file mode 100644
index e8946c8b4037..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/tasty/PositionPickler.scala
+++ /dev/null
@@ -1,138 +0,0 @@
-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._
-import reporting.Message
-
-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[Message]): 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
deleted file mode 100644
index 9c66e43eae80..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/tasty/PositionUnpickler.scala
+++ /dev/null
@@ -1,77 +0,0 @@
-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
deleted file mode 100644
index d8d72a4e651e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/tasty/TastyAnsiiPrinter.scala
+++ /dev/null
@@ -1,9 +0,0 @@
-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
deleted file mode 100644
index c938868a3c48..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/tasty/TastyClassName.scala
+++ /dev/null
@@ -1,68 +0,0 @@
-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
deleted file mode 100644
index b234705413ae..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/tasty/TastyHTMLPrinter.scala
+++ /dev/null
@@ -1,9 +0,0 @@
-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
deleted file mode 100644
index aa657c393815..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/tasty/TastyPickler.scala
+++ /dev/null
@@ -1,80 +0,0 @@
-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
deleted file mode 100644
index 5876b69edfde..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/tasty/TastyPrinter.scala
+++ /dev/null
@@ -1,228 +0,0 @@
-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
deleted file mode 100644
index 5cc172c65439..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/tasty/TastyUnpickler.scala
+++ /dev/null
@@ -1,109 +0,0 @@
-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
deleted file mode 100644
index a3dedaaec685..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/tasty/TreeBuffer.scala
+++ /dev/null
@@ -1,189 +0,0 @@
-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
deleted file mode 100644
index 86e5ba228cff..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/tasty/TreePickler.scala
+++ /dev/null
@@ -1,802 +0,0 @@
-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(em"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 if fun.symbol.originalSignaturePolymorphic.exists then
-            writeByte(APPLYsigpoly)
-            withLength {
-              pickleTree(fun)
-              pickleType(fun.tpe.widenTermRefExpr, richTypes = true) // this widens to a MethodType, so need richTypes
-              args.foreach(pickleTree)
-            }
-          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
deleted file mode 100644
index fcc449af3632..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/tasty/TreeUnpickler.scala
+++ /dev/null
@@ -1,1641 +0,0 @@
-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
-import annotation.unchecked.uncheckedCaptures
-
-/** 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 DetachedContext): 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
-            class RootCompleter extends Completer(subReader(start, end)), SymbolLoaders.SecondCompleter
-            rootd.info = adjustIfModule(RootCompleter())
-            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]
-      @uncheckedCaptures 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 APPLYsigpoly =>
-              val fn = readTerm()
-              val methType = readType()
-              val args = until(end)(readTerm())
-              val fun2 = typer.Applications.retypeSignaturePolymorphicFn(fn, methType)
-              tpd.Apply(fun2, args)
-            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
deleted file mode 100644
index 2aeb1bdeefcc..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/PickleBuffer.scala
+++ /dev/null
@@ -1,292 +0,0 @@
-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
deleted file mode 100644
index f135de7e43e9..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/PickleFormat.scala
+++ /dev/null
@@ -1,227 +0,0 @@
-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
deleted file mode 100644
index f1ed9a284579..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/Scala2Erasure.scala
+++ /dev/null
@@ -1,257 +0,0 @@
-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 TypeError(em"Unsupported Scala 2 type: Component $parent of intersection is annotated.")
-    case tp @ TypeRef(prefix, _) if !tp.symbol.exists && prefix.dealias.isInstanceOf[Scala2RefinedType] =>
-      throw TypeError(em"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.collectCC { 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
deleted file mode 100644
index 6cf08b3384d9..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/Scala2Flags.scala
+++ /dev/null
@@ -1,107 +0,0 @@
-/* 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
deleted file mode 100644
index 7bc99ce24fb4..000000000000
--- a/tests/pos-with-compiler-cc/dotc/core/unpickleScala2/Scala2Unpickler.scala
+++ /dev/null
@@ -1,1381 +0,0 @@
-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: DetachedContext)
-  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
deleted file mode 100644
index e41bfcd5d09a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/coverage/Coverage.scala
+++ /dev/null
@@ -1,26 +0,0 @@
-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
deleted file mode 100644
index c565c2bb1116..000000000000
--- a/tests/pos-with-compiler-cc/dotc/coverage/Location.scala
+++ /dev/null
@@ -1,50 +0,0 @@
-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
deleted file mode 100644
index 26efa8934e00..000000000000
--- a/tests/pos-with-compiler-cc/dotc/coverage/Serializer.scala
+++ /dev/null
@@ -1,111 +0,0 @@
-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
deleted file mode 100644
index 85a56b9f1d15..000000000000
--- a/tests/pos-with-compiler-cc/dotc/decompiler/DecompilationPrinter.scala
+++ /dev/null
@@ -1,48 +0,0 @@
-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
deleted file mode 100644
index 5bf526bd4bdd..000000000000
--- a/tests/pos-with-compiler-cc/dotc/decompiler/IDEDecompilerDriver.scala
+++ /dev/null
@@ -1,50 +0,0 @@
-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
deleted file mode 100644
index 6fd8ac298999..000000000000
--- a/tests/pos-with-compiler-cc/dotc/decompiler/Main.scala
+++ /dev/null
@@ -1,27 +0,0 @@
-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], DetachedContext)] = {
-    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.detach)
-  }
-}
diff --git a/tests/pos-with-compiler-cc/dotc/decompiler/PartialTASTYDecompiler.scala b/tests/pos-with-compiler-cc/dotc/decompiler/PartialTASTYDecompiler.scala
deleted file mode 100644
index 62bf158d0ef6..000000000000
--- a/tests/pos-with-compiler-cc/dotc/decompiler/PartialTASTYDecompiler.scala
+++ /dev/null
@@ -1,11 +0,0 @@
-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
deleted file mode 100644
index 62f3e75d2001..000000000000
--- a/tests/pos-with-compiler-cc/dotc/decompiler/TASTYDecompiler.scala
+++ /dev/null
@@ -1,23 +0,0 @@
-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
deleted file mode 100644
index 74c680bda1b7..000000000000
--- a/tests/pos-with-compiler-cc/dotc/fromtasty/AlreadyLoadedCompilationUnit.scala
+++ /dev/null
@@ -1,10 +0,0 @@
-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
deleted file mode 100644
index 979fae239e59..000000000000
--- a/tests/pos-with-compiler-cc/dotc/fromtasty/Debug.scala
+++ /dev/null
@@ -1,74 +0,0 @@
-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
deleted file mode 100644
index 86ae99b3e0f9..000000000000
--- a/tests/pos-with-compiler-cc/dotc/fromtasty/ReadTasty.scala
+++ /dev/null
@@ -1,84 +0,0 @@
-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(em"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
deleted file mode 100644
index 77021efa3050..000000000000
--- a/tests/pos-with-compiler-cc/dotc/fromtasty/TASTYCompilationUnit.scala
+++ /dev/null
@@ -1,8 +0,0 @@
-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
deleted file mode 100644
index 923892b62f13..000000000000
--- a/tests/pos-with-compiler-cc/dotc/fromtasty/TASTYCompiler.scala
+++ /dev/null
@@ -1,18 +0,0 @@
-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
deleted file mode 100644
index 49ac246ccb86..000000000000
--- a/tests/pos-with-compiler-cc/dotc/fromtasty/TASTYRun.scala
+++ /dev/null
@@ -1,36 +0,0 @@
-package dotty.tools
-package dotc
-package fromtasty
-
-import scala.language.unsafeNulls
-
-import io.{JarArchive, AbstractFile, Path}
-import core.Contexts._
-import core.Decorators.em
-import java.io.File
-import annotation.constructorOnly
-
-class TASTYRun(comp: Compiler, @constructorOnly 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(em"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
deleted file mode 100644
index bc04cc648a65..000000000000
--- a/tests/pos-with-compiler-cc/dotc/fromtasty/TastyFileUtil.scala
+++ /dev/null
@@ -1,50 +0,0 @@
-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
deleted file mode 100644
index b85454b8ba35..000000000000
--- a/tests/pos-with-compiler-cc/dotc/inlines/InlineReducer.scala
+++ /dev/null
@@ -1,451 +0,0 @@
-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.
-    *
-    *  This variant of beta-reduction preserves the integrity of `Inlined` tree nodes.
-    */
-  def betaReduce(tree: Tree)(using Context): Tree = tree match {
-    case Apply(Select(cl, nme.apply), args) if defn.isFunctionType(cl.tpe) =>
-      val bindingsBuf = new DefBuffer
-      def recur(cl: Tree): Option[Tree] = cl match
-        case Block((ddef : DefDef) :: Nil, closure: Closure) if ddef.symbol == closure.meth.symbol =>
-          ddef.tpe.widen match
-            case mt: MethodType if ddef.paramss.head.length == args.length =>
-              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)
-              Some(expander.transform(ddef.rhs))
-            case _ => None
-        case Block(stats, expr) if stats.forall(isPureBinding) =>
-          recur(expr).map(cpy.Block(cl)(stats, _))
-        case Inlined(call, bindings, expr) if bindings.forall(isPureBinding) =>
-          recur(expr).map(cpy.Inlined(cl)(call, bindings, _))
-        case Typed(expr, tpt) =>
-          recur(expr)
-        case _ => None
-      recur(cl) match
-        case Some(reduced) =>
-          Block(bindingsBuf.toList, reduced).withSpan(tree.span)
-        case None =>
-          tree
-    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 can contain Bind nodes in type parameter lists,
-        // for that case tree looks like this:
-        //   UnApply[t @ t](pats)(implicits): T[t]
-        // Test case is pos/inline-caseclass.scala.
-        // Alternatively, for explicitly specified type binds in type annotations like in
-        //   case A(B): A[t]
-        // the tree will look like this:
-        //   Unapply[t](pats)(implicits) : T[t @ t]
-        // and the binds will be found in the type tree instead
-        // Test case is pos-macros/i15971
-        val tptBinds = getBinds(Set.empty[TypeSymbol], tpt)
-        val binds: Set[TypeSymbol] = pat match {
-          case UnApply(TypeApply(_, tpts), _, _) =>
-            getBinds(Set.empty[TypeSymbol], tpts) ++ tptBinds
-          case _ => tptBinds
-        }
-
-        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
deleted file mode 100644
index bb0acb564da6..000000000000
--- a/tests/pos-with-compiler-cc/dotc/inlines/Inliner.scala
+++ /dev/null
@@ -1,1081 +0,0 @@
-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 DetachedContext)
-    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 DetachedContext):
-  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(em"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.detach
-
-    def inlinedFromOutside(tree: Tree)(span: Span)(using Context): 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)
-          }
-        }).detach,
-      treeMap = inDetachedContext {
-        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.toMessage
-          case _ => em"A literal string is expected as an argument to `compiletime.error`. Got $msgArg"
-        }
-        // 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.detach.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, em"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 DetachedContext): (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)
-          }
-        }).detach,
-        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
deleted file mode 100644
index 1e55938f7c59..000000000000
--- a/tests/pos-with-compiler-cc/dotc/inlines/Inlines.scala
+++ /dev/null
@@ -1,471 +0,0 @@
-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)
-
-    if ctx.isAfterTyper then
-      // During typer we wait with cross version checks until PostTyper, in order
-      // not to provoke cyclic references. See i16116 for a test case.
-      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,
-          em"""|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.""",
-          (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 DetachedContext) 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 =>
-                  errorTree(call, evTyper.missingArgMsg(evidence, tpt.tpe, ""))
-                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
deleted file mode 100644
index 9bb0bacd7a78..000000000000
--- a/tests/pos-with-compiler-cc/dotc/inlines/PrepareInlineable.scala
+++ /dev/null
@@ -1,323 +0,0 @@
-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, CrossStageSafety, 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): DetachedContext =
-    ctx.fresh.setProperty(InlineAccessorsKey, new InlineAccessors).detach
-
-  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.detach
-          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(em"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 CrossStageSafety(freshStagingContext).transform(body) // Ignore output, only check staging levels
-        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
deleted file mode 100644
index ead3e6c413c9..000000000000
--- a/tests/pos-with-compiler-cc/dotc/interactive/Completion.scala
+++ /dev/null
@@ -1,565 +0,0 @@
-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.Phases
-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).withPhase(Phases.typerPhase))
-  }
-
-  /**
-   * 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.detach.outersIterator.foreach { case ctx @ given DetachedContext @unchecked =>
-        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
-          .collectCC { 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)
-            .collectCC { 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.collectCC { 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).collectCC {
-        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: DetachedContext) extends Pure
-
-  /**
-   * 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
deleted file mode 100644
index 73697036a8d6..000000000000
--- a/tests/pos-with-compiler-cc/dotc/interactive/Interactive.scala
+++ /dev/null
@@ -1,445 +0,0 @@
-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): DetachedContext = stats match {
-    case Nil =>
-      ctx.detach
-    case first :: _ if first eq stat =>
-      ctx.exprContext(stat, exprOwner).detach
-    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): DetachedContext = path match {
-    case Nil | _ :: Nil =>
-      ctx.fresh.detach
-    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.detach
-          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).detach
-          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.detach
-          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
deleted file mode 100644
index 38a93125a342..000000000000
--- a/tests/pos-with-compiler-cc/dotc/interactive/InteractiveCompiler.scala
+++ /dev/null
@@ -1,21 +0,0 @@
-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
deleted file mode 100644
index afd8424fb874..000000000000
--- a/tests/pos-with-compiler-cc/dotc/interactive/InteractiveDriver.scala
+++ /dev/null
@@ -1,340 +0,0 @@
-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: DetachedContext = {
-    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.detach
-  }
-
-  private var myCtx: DetachedContext = myInitCtx
-  def currentCtx: DetachedContext = 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.detach
-
-      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).detach
-
-      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
deleted file mode 100644
index 60f01396e91e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/interactive/SourceTree.scala
+++ /dev/null
@@ -1,80 +0,0 @@
-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
deleted file mode 100644
index c63409d0d52b..000000000000
--- a/tests/pos-with-compiler-cc/dotc/parsing/CharArrayReader.scala
+++ /dev/null
@@ -1,128 +0,0 @@
-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
deleted file mode 100644
index 7e17df5ba149..000000000000
--- a/tests/pos-with-compiler-cc/dotc/parsing/JavaParsers.scala
+++ /dev/null
@@ -1,1031 +0,0 @@
-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 DetachedContext) 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: Message, skipIt: Boolean): Unit =
-      syntaxError(in.offset, msg, skipIt)
-
-    def syntaxError(offset: Int, msg: Message, 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 =
-          em"${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(em"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, em"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.JavaInterface)
-      }
-      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[Tree] = List(
-      javaLangObject(),
-      Select(javaLangDot(nme.annotation), tpnme.Annotation)
-    )
-    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.JavaInterface | Flags.JavaAnnotation)
-      }
-      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(em"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
deleted file mode 100644
index 248865dff8fc..000000000000
--- a/tests/pos-with-compiler-cc/dotc/parsing/JavaScanners.scala
+++ /dev/null
@@ -1,742 +0,0 @@
-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
-import core.Decorators.em
-
-object JavaScanners {
-
-  class JavaScanner(source: SourceFile, override val startFrom: Offset = 0)(using DetachedContext) 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(em"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(em"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(em"`.` 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(em"illegal character")
-                nextChar()
-              }
-
-            case _ =>
-              if (Character.isUnicodeIdentifierStart(ch)) {
-                putChar(ch)
-                nextChar()
-                getIdentRest()
-              }
-              else {
-                error(em"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(em"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(em"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(em"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(em"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(em"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(em"floating point number too large")
-        if (negated) -value else value
-      } catch {
-        case _: NumberFormatException =>
-          error(em"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
deleted file mode 100644
index 3e73b6d95adb..000000000000
--- a/tests/pos-with-compiler-cc/dotc/parsing/JavaTokens.scala
+++ /dev/null
@@ -1,92 +0,0 @@
-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
deleted file mode 100644
index a67bca34cae2..000000000000
--- a/tests/pos-with-compiler-cc/dotc/parsing/ParserPhase.scala
+++ /dev/null
@@ -1,60 +0,0 @@
-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
deleted file mode 100644
index 5024f2f9e366..000000000000
--- a/tests/pos-with-compiler-cc/dotc/parsing/Parsers.scala
+++ /dev/null
@@ -1,4266 +0,0 @@
-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
-
-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 DetachedContext) {
-
-    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
-
-    /** Unconditionally issue an error at given span, without
-     *  updating lastErrorOffset.
-     */
-    def syntaxError(msg: Message, span: Span): Unit =
-      report.error(msg, source.atSpan(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 DetachedContext) 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: 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(em"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 em"end of $what expected but ${showToken(found)} found")
-          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(em"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
-                em"""Line is indented too far to the right, or a `{` is missing before:
-                  |
-                  |${t.tryToShow}"""
-              else
-                in.spaceTabMismatchMsg(startIndentWidth, nextIndentWidth),
-              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(em"Line is indented too far to the right, or a `{` or `:` is missing", 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 || Feature.fewerBracesEnabled) then
-        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 =
-      Feature.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(
-            em"""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.toMessage)
-          }
-        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(
-            em"""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(em"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(em"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(em"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(em"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(em"$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")
-            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(
-              em"λ 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(em"explicit captureSet is superfluous for impure call-by-name type", start)
-            tp1
-          case CapturingTypeTree(_, tp1: ByNameTypeTree) =>
-            syntaxError(em"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()
-
-    private def maybeInto(tp: () => Tree) =
-      if in.isIdent(nme.into)
-          && in.featureEnabled(Feature.into)
-          && canStartTypeTokens.contains(in.lookahead.token)
-      then atSpan(in.skipToken()) { Into(tp()) }
-      else tp()
-
-    /** FunArgType ::=  Type
-     *               |  `=>' Type
-     *               |  [CaptureSet] `->' Type
-     */
-    val funArgType: () => Tree = () => paramTypeOf(typ)
-
-    /** ParamType  ::=  ParamValueType
-     *               |  `=>' ParamValueType
-     *               |  [CaptureSet] `->' ParamValueType
-     */
-    def paramType(): Tree = paramTypeOf(paramValueType)
-
-    /** ParamValueType ::= [`into`] Type [`*']
-     */
-    def paramValueType(): Tree = {
-      val t = maybeInto(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(
-          em"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(em"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(
-          em"""`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(
-              em"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(em"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 ColonArgument
-     *                  | 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
-     *  ColonArgument ::= colon [LambdaStart]
-     *                    indent (CaseClauses | Block) outdent
-     *  LambdaStart   ::= FunParams (‘=>’ | ‘?=>’)
-     *                 |  HkTypeParamClause ‘=>’
-     *  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(em"""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.""")
-          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     ::= PatVar Ascription
-     *                  | [‘-’] integerLiteral Ascription
-     *                  | [‘-’] floatingPointLiteral Ascription
-     *                  | Pattern2
-     */
-    def pattern1(location: Location = Location.InPattern): Tree =
-      val p = pattern2()
-      if (isVarPattern(p) || p.isInstanceOf[Number]) && 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(
-                em"The [this] qualifier will be deprecated in the future; it should be dropped.")
-            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(em"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(em"`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(em"`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).detach
-          for case ImportSelector(id @ Ident(imported), EmptyTree, _) <- selectors do
-            if Feature.handleGlobalLanguageImport(prefix, imported) && !outermost then
-              syntaxError(em"this language import is only allowed at the toplevel", id.span)
-            if allSourceVersionNames.contains(imported) && prefix.isEmpty then
-              if !outermost then
-                syntaxError(em"source version import is only allowed at the toplevel", id.span)
-              else if ctx.compilationUnit.sourceVersion.isDefined then
-                syntaxError(em"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 = em"`$imported` is not a valid source version"
-                val msg = candidate match
-                  case Some(member) => baseMsg.append(i", 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(em"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`.""",
-                  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(
-            em"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(em"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(em"cannot combine lower bound and match type alias", eqOffset)
-                  }
-                case _ =>
-                  if mods.is(Opaque) then
-                    rhs = TypeBoundsTree(bounds.lo, bounds.hi, rhs)
-                  else
-                    syntaxError(em"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(em"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(em"no extension method allowed here since leading parameter was already given", stat.span)
-        else if !stat.mods.is(ExtensionMethod) && vparamss.isEmpty then
-          syntaxError(em"an extension method is required here", stat.span)
-        else if tparams.nonEmpty && stat.leadingTypeParams.nonEmpty then
-          syntaxError(em"extension method cannot have type parameters since some were already given previously",
-            stat.leadingTypeParams.head.span)
-        else if stat.rhs.isEmpty then
-          syntaxError(em"extension method cannot be abstract", stat.span)
-      case EmptyTree =>
-      case stat =>
-        syntaxError(em"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 refinedTypeRest(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(em"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(em"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(em"`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(
-              em"`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(em"`=>` 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] =
-        def ok = tree :: Nil
-        def fail(msg: Message) =
-          syntaxError(msg, tree.span)
-          Nil
-        tree match
-          case tree: ValDef if tree.mods.is(Mutable) =>
-            fail(em"""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 =>
-            fail(em"refinement cannot be ${(tree.mods.flags & ModifierFlags).flagStrings().mkString("`", "`, `", "`")}")
-          case tree: DefDef if tree.termParamss.nestedExists(!_.rhs.isEmpty) =>
-            fail(em"refinement cannot have default arguments")
-          case tree: ValOrDefDef =>
-            if tree.rhs.isEmpty then ok
-            else fail(em"refinement cannot have a right-hand side")
-          case tree: TypeDef =>
-            if !tree.isClassDef then ok
-            else fail(em"refinement cannot be a class or trait")
-          case _ =>
-            fail(em"this kind of definition cannot be a refinement")
-
-      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 DetachedContext) 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
deleted file mode 100644
index 71540df26539..000000000000
--- a/tests/pos-with-compiler-cc/dotc/parsing/Scanners.scala
+++ /dev/null
@@ -1,1706 +0,0 @@
-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, fewerBracesEnabled}
-import config.SourceVersion.`3.0`
-import reporting.{NoProfile, Profile, Message}
-
-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 DetachedContext) extends CharArrayReader with TokenData {
-    val buf: Array[Char] = source.content
-    def nextToken(): Unit
-
-    // Errors -----------------------------------------------------------------
-
-    /** the last error offset
-      */
-    var errOffset: Offset = NoOffset
-
-    /** Implements CharArrayReader's error method */
-    protected def error(msg: String, off: Offset): Unit =
-      error(msg.toMessage, off)
-
-    /** Generate an error at the given offset */
-    def error(msg: Message, off: Offset = offset): Unit = {
-      errorButContinue(msg, off)
-      token = ERROR
-      errOffset = off
-    }
-
-    def errorButContinue(msg: Message, 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: Message): Unit = {
-      report.incompleteInputError(msg, 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(em"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 ictx: DetachedContext) 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(em"illegal combination of -rewrite targets: ${enabled(0).name} and ${enabled(1).name}")
-    }
-
-    private var myLanguageImportContext: DetachedContext = ictx
-    def languageImportContext = myLanguageImportContext
-    final def languageImportContext_=(c: DetachedContext) = myLanguageImportContext = c
-
-    def featureEnabled(name: TermName) = Feature.enabled(name)(using languageImportContext)
-    def erasedEnabled = featureEnabled(Feature.erasedDefinitions)
-
-    private var postfixOpsEnabledCache = false
-    private var postfixOpsEnabledCtx: DetachedContext = 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(
-            em"$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(
-                    em"""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): Message =
-      em"""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.scala
-      =>
-        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(em"illegal character '${toUnicode(high)}${toUnicode(low)}'")
-        else if !strict then
-          putChar(high)
-          res = true
-        else
-          error(em"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(em"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(em"empty character literal (use '\\'' for single quote)")
-                  else if litBuf.length != 1 then error(em"illegal codepoint in Char constant: ${litBuf.toString.map(toUnicode).mkString("'", "", "'")}")
-                  else finishCharLit()
-                else if isEmptyCharLit then error(em"empty character literal")
-                else error(em"unclosed character literal")
-              case _ =>
-                error(em"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(em"illegal character")
-            nextChar()
-          }
-        case _ =>
-          def fetchOther() =
-            if (ch == '\u21D2') {
-              nextChar(); token = ARROW
-              report.deprecationWarning(em"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(em"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(em"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(em"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(em"empty quoted identifier")
-        else if (name == nme.WILDCARD)
-          error(em"wildcard invalid as backquoted identifier")
-      }
-      else error(em"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(em"unclosed string literal")
-    }
-
-    private def getRawStringLit(): Unit =
-      if (ch == '\"') {
-        nextRawChar()
-        if (isTripleQuote()) {
-          setStrVal()
-          token = STRINGLIT
-        }
-        else
-          getRawStringLit()
-      }
-      else if (ch == SU)
-        incompleteInputError(em"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".toMessage, off = charOffset - 2)
-          putChar('$')
-          getStringPart(multiLine)
-      }
-      else {
-        val isUnclosedLiteral = !isUnicodeEscape && (ch == SU || (!multiLine && (ch == CR || ch == LF)))
-        if (isUnclosedLiteral)
-          if (multiLine)
-            incompleteInputError(em"unclosed multi-line string literal")
-          else
-            error(em"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(em"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(em"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 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
deleted file mode 100644
index 0d681b663135..000000000000
--- a/tests/pos-with-compiler-cc/dotc/parsing/ScriptParsers.scala
+++ /dev/null
@@ -1,147 +0,0 @@
-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 DetachedContext) 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
deleted file mode 100644
index dba0ad3fa2ee..000000000000
--- a/tests/pos-with-compiler-cc/dotc/parsing/Tokens.scala
+++ /dev/null
@@ -1,300 +0,0 @@
-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 canStartTypeTokens: TokenSet = canStartInfixTypeTokens | BitSet(LBRACE)
-
-  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.into, 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
deleted file mode 100644
index a1f9c8d73ad4..000000000000
--- a/tests/pos-with-compiler-cc/dotc/parsing/package.scala
+++ /dev/null
@@ -1,40 +0,0 @@
-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
deleted file mode 100644
index 2c6c5361e51c..000000000000
--- a/tests/pos-with-compiler-cc/dotc/parsing/xml/MarkupParserCommon.scala
+++ /dev/null
@@ -1,257 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     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
deleted file mode 100644
index 77c5a1bf376b..000000000000
--- a/tests/pos-with-compiler-cc/dotc/parsing/xml/MarkupParsers.scala
+++ /dev/null
@@ -1,484 +0,0 @@
-package dotty.tools
-package dotc
-package parsing
-package xml
-
-import scala.language.unsafeNulls
-
-import scala.collection.mutable
-import core.Contexts.Context
-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.{em, 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)(using Context) 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(em"${c.getMessage}$debugLastElem>", debugLastPos)
-        case _: ArrayIndexOutOfBoundsException =>
-          parser.syntaxError(em"missing end tag in XML literal for <$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.toMessage, 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.toMessage, 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
deleted file mode 100644
index 0e70cc077fa4..000000000000
--- a/tests/pos-with-compiler-cc/dotc/parsing/xml/SymbolicXMLBuilder.scala
+++ /dev/null
@@ -1,261 +0,0 @@
-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
deleted file mode 100644
index 87412cf6d69c..000000000000
--- a/tests/pos-with-compiler-cc/dotc/parsing/xml/Utility.scala
+++ /dev/null
@@ -1,173 +0,0 @@
-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
deleted file mode 100644
index 21bb0fa2be54..000000000000
--- a/tests/pos-with-compiler-cc/dotc/plugins/Plugin.scala
+++ /dev/null
@@ -1,196 +0,0 @@
-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
deleted file mode 100644
index 0c28df74d297..000000000000
--- a/tests/pos-with-compiler-cc/dotc/plugins/Plugins.scala
+++ /dev/null
@@ -1,278 +0,0 @@
-package dotty.tools.dotc
-package plugins
-
-import scala.language.unsafeNulls
-
-import core._
-import Contexts._
-import Decorators.em
-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
-    inDetachedContext:
-      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(em"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(em"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
deleted file mode 100644
index f4bbd74842c8..000000000000
--- a/tests/pos-with-compiler-cc/dotc/printing/Formatting.scala
+++ /dev/null
@@ -1,167 +0,0 @@
-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: _*)
-    }
-  }
-
-  /** 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 = found.show
-    val exp = expected.show
-    DiffUtil.mkColoredTypeDiff(fnd, exp) match
-      case (fnd1, exp1, change)
-      if change < 0.5 && ctx.settings.color.value != "never" => (fnd1, exp1)
-      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
deleted file mode 100644
index 018bf65b851d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/printing/Highlighting.scala
+++ /dev/null
@@ -1,72 +0,0 @@
-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 DetachedContext) extends Pure {
-    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
deleted file mode 100644
index c9ac4a5af4ce..000000000000
--- a/tests/pos-with-compiler-cc/dotc/printing/MessageLimiter.scala
+++ /dev/null
@@ -1,61 +0,0 @@
-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
deleted file mode 100644
index c79d4b3a8a83..000000000000
--- a/tests/pos-with-compiler-cc/dotc/printing/PlainPrinter.scala
+++ /dev/null
@@ -1,727 +0,0 @@
-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: DetachedContext) extends Printer {
-
-  /** The context of all public methods in Printer and subclasses.
-   *  Overridden in RefinedPrinter.
-   */
-  def printerContext: DetachedContext = _ctx.addMode(Mode.Printing).detach
-  protected given [DummyToEnforceDef]: DetachedContext = 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): Text =
-    val keyword = rt.refinedInfo match {
-      case _: ExprType | _: MethodOrPoly => "def "
-      case _: TypeBounds => "type "
-      case _: TypeProxy => "val "
-      case _ => ""
-    }
-    (keyword ~ 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.message}>"
-      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 =>
-        def toTextCaret(tp: Type) = if printDebug then toTextLocal(tp) ~ Str("^") else toText(tp)
-        if (tp.isInstantiated)
-          toTextCaret(tp.instanceOpt)
-        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) toTextCaret(bounds.lo)
-          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")
-        }
-      val depsText = if Config.showConstraintDeps then c.depsToString else ""
-      //Printer.debugPrintUnique = false
-      Text.lines(List(uninstVarsText, constrainedText, boundsText, orderingText, depsText))
-    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
deleted file mode 100644
index eff283b345ce..000000000000
--- a/tests/pos-with-compiler-cc/dotc/printing/Printer.scala
+++ /dev/null
@@ -1,200 +0,0 @@
-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 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 prec = parsing.precedence(op)
-   *  // 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 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
deleted file mode 100644
index 561097472ae3..000000000000
--- a/tests/pos-with-compiler-cc/dotc/printing/RefinedPrinter.scala
+++ /dev/null
@@ -1,1134 +0,0 @@
-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: DetachedContext) extends PlainPrinter(_ctx) {
-
-  /** A stack of enclosing DefDef, TypeDef, or ClassDef, or ModuleDefs nodes */
-  private var enclosingDef: untpd.Tree = untpd.EmptyTree
-  private var myCtx: DetachedContext = super.printerContext
-  private var printPos = ctx.settings.YprintPos.value
-  private val printLines = ctx.settings.printLines.value
-
-  override def printerContext: DetachedContext = myCtx
-
-  def withEnclosingDef(enclDef: Tree[?])(op: => Text): Text = {
-    val savedCtx = myCtx
-    if (enclDef.hasType && enclDef.symbol.exists)
-      myCtx = ctx.withOwner(enclDef.symbol).detach
-    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).detach
-    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 tp.isConvertibleParam then "into " ~ toText(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) =>
-        val bodyText = if bindings.isEmpty then toText(body) else blockText(bindings :+ body)
-        if homogenizedView || !ctx.settings.XprintInline.value then bodyText
-        else if call.isEmpty then stringText("{{") ~ stringText("/* inlined from outside */") ~ bodyText ~ stringText("}}")
-        else keywordText("{{") ~ keywordText("/* inlined from ") ~ toText(call) ~ keywordText(" */") ~ bodyText ~ keywordText("}}")
-      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).detach
-        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.typeOpt)
-    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
deleted file mode 100644
index f8f9baec4edd..000000000000
--- a/tests/pos-with-compiler-cc/dotc/printing/ReplPrinter.scala
+++ /dev/null
@@ -1,61 +0,0 @@
-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: DetachedContext) 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
deleted file mode 100644
index 4a0e68861a1a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/printing/Showable.scala
+++ /dev/null
@@ -1,36 +0,0 @@
-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
deleted file mode 100644
index 53e6b9472f5e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/printing/SyntaxHighlighting.scala
+++ /dev/null
@@ -1,147 +0,0 @@
-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
deleted file mode 100644
index 411fa74ebffa..000000000000
--- a/tests/pos-with-compiler-cc/dotc/printing/Texts.scala
+++ /dev/null
@@ -1,213 +0,0 @@
-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
-    }
-
-    //                 Str Ver Clo Flu
-    // isVertical       F   T   F   F
-    // isClosed         F   T   T   F
-    // isFluid          F   F   T   T
-    // isSplittable     F   F   F   T
-    def isVertical: Boolean = isInstanceOf[Vertical]
-    def isClosed: Boolean = isVertical || isInstanceOf[Closed]
-    def isFluid: Boolean = isInstanceOf[Fluid]
-    def isSplittable: Boolean = isFluid && !isClosed
-
-    def close: Text = if isSplittable then Closed(relems) else this
-
-    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 =
-      Fluid(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.replaceAll("[ ]+$", ""))
-      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 this match
-        case Fluid(relems1) if !isClosed => that match
-          case Fluid(relems2) if !that.isClosed => Fluid(relems2 ++ relems1)
-          case _                                => Fluid(that +: relems1)
-        case _             => that match
-          case Fluid(relems2) if !that.isClosed => Fluid(relems2 :+ this)
-          case _                                => 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.reduceRight((a, b) => (a ~ sep).close ~ b)
-      }
-
-    /** 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)
-    override def toString = this match
-      case Str(s, EmptyLineRange) => s"Str($s)"
-      case Str(s, lineRange)      => s"Str($s, $lineRange)"
-  }
-
-  case class Vertical(relems: List[Text]) extends Text
-  case class Fluid(relems: List[Text]) extends Text
-
-  class Closed(relems: List[Text]) extends Fluid(relems):
-    override def productPrefix = "Closed"
-
-  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
deleted file mode 100644
index b1d091ca45c1..000000000000
--- a/tests/pos-with-compiler-cc/dotc/printing/package.scala
+++ /dev/null
@@ -1,29 +0,0 @@
-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
deleted file mode 100644
index 1c52e47ade7e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/profile/AsyncHelper.scala
+++ /dev/null
@@ -1,142 +0,0 @@
-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 extends Pure {
-
-  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 DetachedContext) 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 DetachedContext) 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 DetachedContext) 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
deleted file mode 100644
index 60f44db16add..000000000000
--- a/tests/pos-with-compiler-cc/dotc/profile/ExtendedThreadMxBean.java
+++ /dev/null
@@ -1,305 +0,0 @@
-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 {
-            Class<?> cls = Class.forName("com.sun.management.ThreadMXBean");
-            getThreadUserTimeMethod = cls.getMethod("getThreadUserTime", long[].class);
-            isThreadAllocatedMemoryEnabledMethod = cls.getMethod("isThreadAllocatedMemoryEnabled");
-            setThreadAllocatedMemoryEnabledMethod = cls.getMethod("setThreadAllocatedMemoryEnabled", Boolean.TYPE);
-            getThreadAllocatedBytesMethod1 = cls.getMethod("getThreadAllocatedBytes", Long.TYPE);
-            getThreadAllocatedBytesMethod2 = cls.getMethod("getThreadAllocatedBytes", long[].class);
-            isThreadAllocatedMemorySupportedMethod = cls.getMethod("isThreadAllocatedMemorySupported");
-            getThreadCpuTimeMethod = cls.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
deleted file mode 100644
index 274be637eb8e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/profile/ExternalToolHook.java
+++ /dev/null
@@ -1,17 +0,0 @@
-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
deleted file mode 100644
index 35c98ac2a0d2..000000000000
--- a/tests/pos-with-compiler-cc/dotc/profile/Profiler.scala
+++ /dev/null
@@ -1,264 +0,0 @@
-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 extends Pure {
-
-  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 DetachedContext) 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/Interpreter.scala b/tests/pos-with-compiler-cc/dotc/quoted/Interpreter.scala
deleted file mode 100644
index 061b2f3d3890..000000000000
--- a/tests/pos-with-compiler-cc/dotc/quoted/Interpreter.scala
+++ /dev/null
@@ -1,371 +0,0 @@
-package dotty.tools.dotc
-package quoted
-
-import scala.language.unsafeNulls
-
-import scala.collection.mutable
-import scala.reflect.ClassTag
-
-import java.io.{PrintWriter, StringWriter}
-import java.lang.reflect.{InvocationTargetException, Method => JLRMethod}
-
-import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.ast.TreeMapWithImplicits
-import dotty.tools.dotc.core.Annotations._
-import dotty.tools.dotc.core.Constants._
-import dotty.tools.dotc.core.Contexts._
-import dotty.tools.dotc.core.Decorators._
-import dotty.tools.dotc.core.Denotations.staticRef
-import dotty.tools.dotc.core.Flags._
-import dotty.tools.dotc.core.NameKinds.FlatName
-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.TypeErasure
-import dotty.tools.dotc.core.Types._
-import dotty.tools.dotc.quoted._
-import dotty.tools.dotc.transform.TreeMapWithStages._
-import dotty.tools.dotc.typer.ImportInfo.withRootImports
-import dotty.tools.dotc.util.SrcPos
-import dotty.tools.dotc.reporting.Message
-import dotty.tools.repl.AbstractFileClassLoader
-
-/** Tree interpreter for metaprogramming constructs */
-abstract class Interpreter(pos: SrcPos, classLoader: ClassLoader)(using DetachedContext):
-  import Interpreter._
-  import tpd._
-
-  type Env = Map[Symbol, Object]
-
-  /** Returns the result of interpreting the code in the tree.
-   *  Return Some of the result or None if the result type is not consistent with the expected type.
-   *  Throws a StopInterpretation if the tree could not be interpreted or a runtime exception ocurred.
-   */
-  final 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(em"Interpreted tree returned a result of an unexpected type. Expected ${ct.runtimeClass} but was ${obj.getClass}", pos)
-        None
-    }
-
-  /** Returns the result of interpreting the code in the tree.
-   *  Throws a StopInterpretation if the tree could not be interpreted or a runtime exception ocurred.
-   */
-  protected def interpretTree(tree: Tree)(implicit env: Env): Object = tree match {
-    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 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(em"Unexpected tree could not be interpreted: ${tree.toString}", 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 if ctx.compilationUnit.isSuspendable  =>
-        if (ctx.settings.XprintSuspension.value)
-          report.echo(i"suspension triggered by a dependency on $name", pos)
-        ctx.compilationUnit.suspend()
-      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 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.toMessage, 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.toMessage, pos)
-        }
-    }
-
-  private object MissingClassDefinedInCurrentRun {
-    def unapply(targetException: NoClassDefFoundError)(using Context): Option[Symbol] = {
-      val className = targetException.getMessage
-      if (className eq 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)
-  }
-end Interpreter
-
-object Interpreter:
-  /** Exception that stops interpretation if some issue is found */
-  class StopInterpretation(val msg: Message, val pos: SrcPos) extends Exception
-
-  object Call:
-    import tpd._
-    /** 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
-      }
-    }
-  end Call
diff --git a/tests/pos-with-compiler-cc/dotc/quoted/MacroExpansion.scala b/tests/pos-with-compiler-cc/dotc/quoted/MacroExpansion.scala
deleted file mode 100644
index 141b349826b4..000000000000
--- a/tests/pos-with-compiler-cc/dotc/quoted/MacroExpansion.scala
+++ /dev/null
@@ -1,18 +0,0 @@
-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
deleted file mode 100644
index a124cbb03d03..000000000000
--- a/tests/pos-with-compiler-cc/dotc/quoted/PickledQuotes.scala
+++ /dev/null
@@ -1,270 +0,0 @@
-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 dotty.tools.dotc.reporting.Message
-
-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).detach).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[Message]()
-      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
deleted file mode 100644
index 604c8da3420a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/quoted/QuoteUtils.scala
+++ /dev/null
@@ -1,30 +0,0 @@
-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
deleted file mode 100644
index c063e437cb19..000000000000
--- a/tests/pos-with-compiler-cc/dotc/quoted/QuotesCache.scala
+++ /dev/null
@@ -1,26 +0,0 @@
-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
deleted file mode 100644
index 369e646e883e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/quoted/TastyString.scala
+++ /dev/null
@@ -1,31 +0,0 @@
-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
deleted file mode 100644
index 87d0cbb7be08..000000000000
--- a/tests/pos-with-compiler-cc/dotc/quoted/reflect/FromSymbol.scala
+++ /dev/null
@@ -1,62 +0,0 @@
-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
deleted file mode 100644
index 4f4b7f261232..000000000000
--- a/tests/pos-with-compiler-cc/dotc/report.scala
+++ /dev/null
@@ -1,131 +0,0 @@
-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 */
-  inline def inform(inline 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 migrationWarning(msg: Message, pos: SrcPos)(using Context): Unit =
-    issueWarning(new MigrationWarning(msg, pos.sourcePos))
-
-  def uncheckedWarning(msg: Message, pos: SrcPos)(using Context): Unit =
-    issueWarning(new UncheckedWarning(msg, pos.sourcePos))
-
-  def featureWarning(msg: Message, pos: SrcPos)(using Context): Unit =
-    issueWarning(new FeatureWarning(msg, pos.sourcePos))
-
-  def featureWarning(feature: String, featureDescription: -> String,
-      featureUseSite: Symbol, required: Boolean, pos: SrcPos)(using Context): Unit =
-    val req = if required then "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 = em"""$featureDescription $req be enabled
-                  |by adding the import clause 'import $fqname'
-                  |or by setting the compiler option -language:$feature.$explain"""
-    if required then error(msg, pos)
-    else issueWarning(new FeatureWarning(msg, pos.sourcePos))
-  end featureWarning
-
-  def warning(msg: Message, pos: SrcPos)(using Context): Unit =
-    issueWarning(new Warning(msg, addInlineds(pos)))
-
-  def warning(msg: Message)(using Context): Unit =
-    warning(msg, NoSourcePosition)
-
-  def warning(msg: -> String, pos: SrcPos = NoSourcePosition)(using Context): Unit =
-    warning(msg.toMessage, pos)
-
-  def error(msg: Message, pos: SrcPos = NoSourcePosition)(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)(using Context): Unit =
-    error(msg.toMessage, pos)
-
-  def error(msg: -> String)(using Context): Unit =
-    error(msg, NoSourcePosition)
-
-  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 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 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.
-   */
-  inline def log(inline 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: Context ?-> String)(using Context): Unit =
-    if (ctx.debug) log(msg)
-
-  def informTime(msg: Context ?-> String, start: Long)(using Context): Unit = {
-    def elapsed = s" in ${currentTimeMillis - start}ms"
-    informProgress(msg + elapsed)
-  }
-
-  def informProgress(msg: Context ?-> String)(using Context): Unit =
-    inform("[" + msg + "]")
-
-  def logWith[T](msg: Context ?-> String)(value: T)(using Context): T = {
-    log(msg + " " + value)
-    value
-  }
-
-  inline def debugwarn(inline 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
deleted file mode 100644
index 630df31014f7..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/AbstractReporter.scala
+++ /dev/null
@@ -1,8 +0,0 @@
-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
deleted file mode 100644
index a95af962c053..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/ConsoleReporter.scala
+++ /dev/null
@@ -1,37 +0,0 @@
-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
deleted file mode 100644
index 630607581fcc..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/Diagnostic.scala
+++ /dev/null
@@ -1,109 +0,0 @@
-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.{Collections, Optional, List => JList}
-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 diagnosticRelatedInformation: JList[interfaces.DiagnosticRelatedInformation] =
-    Collections.emptyList()
-
-  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
deleted file mode 100644
index a7bc7f027517..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/ErrorMessageID.scala
+++ /dev/null
@@ -1,199 +0,0 @@
-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 extends ErrorMessageID(isActive = false) // 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
-  case MissingImplicitArgumentID // errorNumber 172
-  case CannotBeAccessedID // errorNumber 173
-
-  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
deleted file mode 100644
index a2062bd1b2c7..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/ExploringReporter.scala
+++ /dev/null
@@ -1,23 +0,0 @@
-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
deleted file mode 100644
index 9b6a3c75ba5d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/HideNonSensicalMessages.scala
+++ /dev/null
@@ -1,20 +0,0 @@
-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
deleted file mode 100644
index 331dd7f41eb7..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/Message.scala
+++ /dev/null
@@ -1,411 +0,0 @@
-package dotty.tools
-package dotc
-package reporting
-
-import core.*
-import Contexts.*, Decorators.*, Symbols.*, Types.*, Flags.*
-import printing.{RefinedPrinter, MessageLimiter, ErrorMessageLimiter}
-import printing.Texts.Text
-import printing.Formatting.hl
-import config.SourceVersion
-
-import scala.language.unsafeNulls
-
-import scala.annotation.threadUnsafe
-import language.experimental.pureFunctions
-
-/** ## Tips for error message generation
- *
- *  - You can use the `em` interpolator for error messages. It's defined in core.Decorators.
- *  - You can also use a simple string argument for `error` or `warning` (not for the other variants),
- *    but the string should not be interpolated or composed of objects that require a
- *    Context for evaluation.
- *  - When embedding interpolated substrings defined elsewhere in error messages,
- *    use `i` and make sure they are defined as def's instead of vals. That way, the
- *    possibly expensive interpolation will performed only in the case where the message
- *    is eventually printed. Note: At least during typer, it's common for messages
- *    to be discarded without being printed. Also, by making them defs, you ensure that
- *    they will be evaluated in the Message context, which makes formatting safer
- *    and more robust.
- *  - For common messages, or messages that might require explanation, prefer defining
- *    a new `Message` class in file `messages.scala` and use that instead. The advantage is that these
- *    messages have unique IDs that can be referenced elsewhere.
- */
-object Message:
-  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 ""
-
-  private type Recorded = Symbol | ParamRef | SkolemType
-
-  private case class SeenKey(str: String, isType: Boolean)
-
-  /** A class that records printed items of one of the types in `Recorded`,
-   *  adds superscripts for disambiguations, and can explain recorded symbols
-   *  in ` where` clause
-   */
-  private class Seen(disambiguate: Boolean):
-
-    private val seen = new collection.mutable.HashMap[SeenKey, List[Recorded]]:
-      override def default(key: SeenKey) = Nil
-
-    var nonSensical = false
-
-    /** If false, stop all recordings */
-    private var recordOK = disambiguate
-
-    /** Clear all entries and stop further entries to be added */
-    def disable() =
-      seen.clear()
-      recordOK = false
-
-    /** Record an entry `entry` with given String representation `str` and a
-     *  type/term namespace identified by `isType`.
-     *  If the entry was not yet recorded, allocate the next superscript corresponding
-     *  to the same string in the same name space. The first recording is the string proper
-     *  and following recordings get consecutive superscripts starting with 2.
-     *  @return  The possibly superscripted version of `str`.
-     */
-    def record(str: String, isType: Boolean, entry: Recorded)(using Context): String =
-      if !recordOK then return str
-      //println(s"recording $str, $isType, $entry")
-
-      /** 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 = seen(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 then
-        alts = entry :: existing
-        seen(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
-    end record
-
-    /** Create explanation for single `Recorded` type or symbol */
-    private 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}"
-      }
-    end explanation
-
-    /** Produce a where clause with explanations for recorded iterms.
-     */
-    def explanations(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 = 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"
-    end explanations
-  end Seen
-
-  /** Printer to be used when formatting messages */
-  private class Printer(val seen: Seen, _ctx: DetachedContext) extends RefinedPrinter(_ctx):
-
-    /** True if printer should a show 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) then 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 =
-      if !tp.exists || tp.isErroneous then seen.nonSensical = true
-      tp match
-        case tp: TypeRef if useSourceModule(tp.symbol) => Str("object ") ~ super.toText(tp)
-        case _ => super.toText(tp)
-
-    override def toText(sym: Symbol): Text =
-      sym.infoOrCompleter match
-        case _: ErrorType | TypeAlias(_: ErrorType) | NoType => seen.nonSensical = true
-        case _ =>
-      super.toText(sym)
-  end Printer
-
-end Message
-
-/** 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
-  *
-  * Messages modify the rendendering of interpolated strings in several ways:
-  *
-  *  1. The size of the printed code is limited with a MessafeLimiter. If the message
-  *    would get too large or too deeply nested, a `...` is printed instead.
-  *  2. References to module classes are prefixed with `object ` for better recogniability.
-  *  3. A where clause is sometimes added which contains the following additional explanations:
-  *     - Rerences are disambiguated: If a message contains occurrences of the same identifier
-  *       representing different symbols, the duplicates are printed with superscripts
-  *       and the where-clause explains where each symbol is located.
-  *     - Uninstantiated variables are explained in the where-clause with additional
-  *       info about their bounds.
-  *     - Skolems are explained with additional info about their underlying type.
-  *
-  *  Messages inheriting from the NoDisambiguation trait or returned from the
-  *  `noDisambiguation()` method skip point (3) above. This makes sense if the
-  *  message already exolains where different occurrences of the same identifier
-  *  are located. Examples are NamingMsgs such as double definition errors,
-  *  overriding errors, and ambiguous implicit errors.
-  *
-  *  We consciously made the design decision to disambiguate by default and disable
-  *  disambiguation as an opt-in. The reason is that one usually does not consider all
-  *  fine-grained details when writing an error message. If disambiguation is the default,
-  *  some tests will show where clauses that look too noisy and that then can be disabled
-  *  when needed. But if silence is the default, one usually does not realize that
-  *  better info could be obtained by turning disambiguation on.
-  */
-abstract class Message(val errorId: ErrorMessageID)(using DetachedContext) { self =>
-  import Message.*
-
-  /** 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 `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(using Context): String
-
-  /** 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(using Context): String
-
-  /** What gets printed after the message proper */
-  protected def msgPostscript(using Context): String =
-    if ctx eq NoContext then ""
-    else ctx.printer match
-      case msgPrinter: Message.Printer =>
-        myIsNonSensical = msgPrinter.seen.nonSensical
-        val addendum = msgPrinter.seen.explanations
-        msgPrinter.seen.disable()
-          // Clear entries and stop futher recording so that messages containing the current
-          // one don't repeat the explanations or use explanations from the msgPostscript.
-        if addendum.isEmpty then "" else "\n\n" ++ addendum
-      case _ =>
-        ""
-
-  /** 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 myIsNonSensical: Boolean = false
-
-  /** A message is non-sensical if it 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 }
-
-  private var disambiguate: Boolean = true
-
-  def withoutDisambiguation(): this.type =
-    disambiguate = false
-    this
-
-  private def inMessageContext(disambiguate: Boolean)(op: Context ?=> String): String =
-    if ctx eq NoContext then op
-    else
-      val msgContext = ctx.printer match
-        case _: Message.Printer => ctx
-        case _ =>
-          val seen = Seen(disambiguate)
-          val ctx1 = ctx.fresh.setPrinterFn(c => Message.Printer(seen, c.detach))
-          if !ctx1.property(MessageLimiter).isDefined then
-            ctx1.setProperty(MessageLimiter, ErrorMessageLimiter())
-          ctx1
-      op(using msgContext)
-
-  /** The message to report. <nonsensical> tags are filtered out */
-  @threadUnsafe lazy val message: String =
-    inMessageContext(disambiguate)(msg + msgPostscript)
-
-  /** The explanation to report. <nonsensical> tags are filtered out */
-  @threadUnsafe lazy val explanation: String =
-    inMessageContext(disambiguate = false)(explain)
-
-  /** 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)(using NoContext):
-    val kind  = self.kind
-    private val persistedMsg = self.message
-    private val persistedExplain = self.explanation
-    def msg(using Context) = persistedMsg
-    def explain(using Context) = persistedExplain
-    override val canExplain = self.canExplain
-    override def isNonSensical = self.isNonSensical
-
-  def append(suffix: -> String): Message = mapMsg(_ ++ suffix)
-  def prepend(prefix: -> String): Message = mapMsg(prefix ++ _)
-
-  def mapMsg(f: String -> String): Message = new Message(errorId):
-    val kind = self.kind
-    def msg(using Context) = f(self.msg)
-    def explain(using Context) = self.explain
-    override def canExplain = self.canExplain
-
-  def appendExplanation(suffix: -> String): Message = new Message(errorId):
-    val kind = self.kind
-    def msg(using Context) = self.msg
-    def explain(using Context) = 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
-}
-
-/** A marker trait that suppresses generation of `where` clause for disambiguations */
-trait NoDisambiguation extends Message:
-  withoutDisambiguation()
-
-/** The fallback `Message` containing no explanation and having no `kind` */
-final class NoExplanation(msgFn: Context ?-> String)(using DetachedContext) extends Message(ErrorMessageID.NoExplanationID) {
-  def msg(using Context): String = msgFn
-  def explain(using Context): 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
deleted file mode 100644
index f039ed900a76..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/MessageKind.scala
+++ /dev/null
@@ -1,41 +0,0 @@
-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
deleted file mode 100644
index f53359fb8b19..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/MessageRendering.scala
+++ /dev/null
@@ -1,324 +0,0 @@
-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
deleted file mode 100644
index 1088b629ca82..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/Profile.scala
+++ /dev/null
@@ -1,157 +0,0 @@
-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).detach
-        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
deleted file mode 100644
index a72a7eb411a9..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/Reporter.scala
+++ /dev/null
@@ -1,271 +0,0 @@
-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 java.io.{BufferedReader, PrintWriter}
-import scala.annotation.internal.sharable
-import scala.collection.mutable
-import core.Decorators.em
-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: ErrorHandler =
-    (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 = em"there $were ${countString(count, settingName.tail + " warning")}; re-run with $settingName for details"
-      report(Warning(msg, 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
deleted file mode 100644
index 9783a3208a60..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/StoreReporter.scala
+++ /dev/null
@@ -1,51 +0,0 @@
-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
deleted file mode 100644
index 8d7204a93fa2..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/TestReporter.scala
+++ /dev/null
@@ -1,14 +0,0 @@
-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
deleted file mode 100644
index ad47a9d30536..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/ThrowingReporter.scala
+++ /dev/null
@@ -1,17 +0,0 @@
-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
deleted file mode 100644
index 98fd7da3032a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/UniqueMessagePositions.scala
+++ /dev/null
@@ -1,38 +0,0 @@
-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
deleted file mode 100644
index fd79ce3876c7..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/WConf.scala
+++ /dev/null
@@ -1,127 +0,0 @@
-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
-import core.Decorators.em
-
-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.message.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(em"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
deleted file mode 100644
index cd5c5f67ff41..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/messages.scala
+++ /dev/null
@@ -1,2773 +0,0 @@
-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, substitutableTypeSymbolsInScope}
-import typer.ProtoTypes.ViewProto
-import typer.Implicits.*
-import typer.Inferencing
-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 scala.util.matching.Regex
-import java.util.regex.Matcher.quoteReplacement
-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)(using DetachedContext) extends Message(errorId):
-  def kind = MessageKind.Syntax
-
-abstract class TypeMsg(errorId: ErrorMessageID)(using DetachedContext) extends Message(errorId):
-  def kind = MessageKind.Type
-
-trait ShowMatchTrace(tps: Type*)(using DetachedContext) extends Message:
-  override def msgPostscript(using Context): String =
-    super.msgPostscript ++ matchReductionAddendum(tps*)
-
-abstract class TypeMismatchMsg(found: Type, expected: Type)(errorId: ErrorMessageID)(using DetachedContext)
-extends Message(errorId), ShowMatchTrace(found, expected):
-  def kind = MessageKind.TypeMismatch
-  def explain(using Context) = err.whyNoMatchStr(found, expected)
-  override def canExplain = true
-
-abstract class NamingMsg(errorId: ErrorMessageID)(using DetachedContext) extends Message(errorId), NoDisambiguation:
-  def kind = MessageKind.Naming
-
-abstract class DeclarationMsg(errorId: ErrorMessageID)(using DetachedContext) 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)(using DetachedContext) extends Message(errorId):
-  def kind = MessageKind.NotFound
-  def name: Name
-
-abstract class PatternMatchMsg(errorId: ErrorMessageID)(using DetachedContext) extends Message(errorId):
-  def kind = MessageKind.PatternMatch
-
-abstract class CyclicMsg(errorId: ErrorMessageID)(using DetachedContext) extends Message(errorId):
-  def kind = MessageKind.Cyclic
-
-abstract class ReferenceMsg(errorId: ErrorMessageID)(using DetachedContext) extends Message(errorId):
-  def kind = MessageKind.Reference
-
-abstract class EmptyCatchOrFinallyBlock(tryBody: untpd.Tree, errNo: ErrorMessageID)(using DetachedContext)
-extends SyntaxMsg(errNo) {
-  def explain(using Context) = {
-    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
-
-    i"""|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 DetachedContext)
-extends EmptyCatchOrFinallyBlock(tryBody, EmptyCatchBlockID) {
-  def msg(using Context) =
-    i"""|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 DetachedContext)
-extends EmptyCatchOrFinallyBlock(tryBody, EmptyCatchAndFinallyBlockID) {
-  def msg(using Context) =
-    i"""|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 DetachedContext)
-extends SyntaxMsg(DeprecatedWithOperatorID) {
-  def msg(using Context) =
-    i"""${hl("with")} as a type operator has been deprecated; use ${hl("&")} instead"""
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-extends SyntaxMsg(CaseClassMissingParamListID) {
-  def msg(using Context) =
-    i"""|A ${hl("case class")} must have at least one parameter list"""
-
-  def explain(using Context) =
-    i"""|${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 DetachedContext)
-extends TypeMsg(AnonymousFunctionMissingParamTypeID) {
-  def msg(using Context) = {
-    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(using Context) = ""
-}
-
-class WildcardOnTypeArgumentNotAllowedOnNew()(using DetachedContext)
-extends SyntaxMsg(WildcardOnTypeArgumentNotAllowedOnNewID) {
-  def msg(using Context) = "Type argument must be fully defined"
-  def explain(using Context) =
-    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
-    i"""|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 DetachedContext)
-extends NamingMsg(DuplicateBindID) {
-  def msg(using Context) = i"duplicate pattern variable: ${bind.name}"
-
-  def explain(using Context) = {
-    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"
-
-    i"""|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 DetachedContext)
-extends NotFoundMsg(MissingIdentID) {
-  def msg(using Context) = i"Not found: $treeKind$name"
-  def explain(using Context) = {
-    i"""|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 DetachedContext)
-  extends TypeMismatchMsg(found, expected)(TypeMismatchID):
-
-  def msg(using Context) =
-    // 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)
-
-    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 (foundStr, expectedStr) = Formatting.typeDiff(found2, expected2)
-    i"""|Found:    $foundStr
-        |Required: $expectedStr"""
-  end msg
-
-  override def msgPostscript(using Context) =
-    def importSuggestions =
-      if expected.isTopType || found.isBottomType then ""
-      else ctx.typer.importSuggestionAddendum(ViewProto(found.widen, expected))
-    super.msgPostscript
-    ++ addenda.dropWhile(_.isEmpty).headOption.getOrElse(importSuggestions)
-
-  override def explain(using Context) =
-    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 DetachedContext)
-extends NotFoundMsg(NotAMemberID), ShowMatchTrace(site) {
-  //println(i"site = $site, decls = ${site.decls}, source = ${site.typeSymbol.sourceFile}") //DEBUG
-
-  def msg(using Context) = {
-    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("")
-
-    i"$selected $name is not a member of ${site.widen}$finalAddendum"
-  }
-
-  def explain(using Context) = ""
-}
-
-class EarlyDefinitionsNotSupported()(using DetachedContext)
-extends SyntaxMsg(EarlyDefinitionsNotSupportedID) {
-  def msg(using Context) = "Early definitions are not supported; use trait parameters instead"
-
-  def explain(using Context) = {
-    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
-
-    i"""|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 DetachedContext)
-extends SyntaxMsg(TopLevelImplicitClassID) {
-  def msg(using Context) = i"""An ${hl("implicit class")} may not be top-level"""
-
-  def explain(using Context) = {
-    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 ""
-    i"""|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 DetachedContext)
-extends SyntaxMsg(ImplicitCaseClassID) {
-  def msg(using Context) = i"""A ${hl("case class")} may not be defined as ${hl("implicit")}"""
-
-  def explain(using Context) =
-    i"""|Implicit classes may not be case classes. Instead use a plain class:
-        |
-        |implicit class ${cdef.name}...
-        |
-        |"""
-}
-
-class ImplicitClassPrimaryConstructorArity()(using DetachedContext)
-extends SyntaxMsg(ImplicitClassPrimaryConstructorArityID){
-  def msg(using Context) = "Implicit classes must accept exactly one primary constructor parameter"
-  def explain(using Context) = {
-    val example = "implicit class RichDate(date: java.util.Date)"
-    i"""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 DetachedContext)
-extends SyntaxMsg(ObjectMayNotHaveSelfTypeID) {
-  def msg(using Context) = i"""${hl("object")}s must not have a self ${hl("type")}"""
-
-  def explain(using Context) = {
-    val untpd.ModuleDef(name, tmpl) = mdef
-    val ValDef(_, selfTpt, _) = tmpl.self
-    i"""|${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)(using DetachedContext)
-extends SyntaxMsg(RepeatedModifierID) {
-  def msg(using Context) = i"""Repeated modifier $modifier"""
-
-  def explain(using Context) = {
-    val code1 = "private private val Origin = Point(0, 0)"
-    val code2 = "private final val Origin = Point(0, 0)"
-    i"""This happens when you accidentally specify the same modifier twice.
-        |
-        |Example:
-        |
-        |$code1
-        |
-        |instead of
-        |
-        |$code2
-        |
-        |"""
-  }
-}
-
-class InterpolatedStringError()(using DetachedContext)
-extends SyntaxMsg(InterpolatedStringErrorID) {
-  def msg(using Context) = "Error in interpolated string: identifier or block expected"
-  def explain(using Context) = {
-    val code1 = "s\"$new Point(0, 0)\""
-    val code2 = "s\"${new Point(0, 0)}\""
-    i"""|This usually happens when you forget to place your expressions inside curly braces.
-        |
-        |$code1
-        |
-        |should be written as
-        |
-        |$code2
-        |"""
-  }
-}
-
-class UnboundPlaceholderParameter()(using DetachedContext)
-extends SyntaxMsg(UnboundPlaceholderParameterID) {
-  def msg(using Context) = i"""Unbound placeholder parameter; incorrect use of ${hl("_")}"""
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-extends SyntaxMsg(IllegalStartSimpleExprID) {
-  def msg(using Context) = i"expression expected but ${Red(illegalToken)} found"
-  def explain(using Context) = {
-    i"""|An expression cannot start with ${Red(illegalToken)}."""
-  }
-}
-
-class MissingReturnType()(using DetachedContext)
-extends SyntaxMsg(MissingReturnTypeID) {
-  def msg(using Context) = "Missing return type"
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-extends SyntaxMsg(MissingReturnTypeWithReturnStatementID) {
-  def msg(using Context) = i"$method has a return statement; it needs a result type"
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-extends SyntaxMsg(YieldOrDoExpectedInForComprehensionID) {
-  def msg(using Context) = i"${hl("yield")} or ${hl("do")} expected"
-
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-extends Message(ProperDefinitionNotFoundID) {
-  def kind = MessageKind.DocComment
-  def msg(using Context) = i"""Proper definition was not found in ${hl("@usecase")}"""
-
-  def explain(using Context) = {
-    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
-
-    i"""|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 DetachedContext)
-extends SyntaxMsg(ByNameParameterNotSupportedID) {
-  def msg(using Context) = i"By-name parameter type ${tpe} not allowed here."
-
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-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(using Context) =
-    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
-    i"""|$msgPrefix type arguments for $prettyName$expectedArgString
-        |expected: $expectedArgString
-        |actual:   $actualArgString"""
-
-  def explain(using Context) = {
-    val tooManyTypeParams =
-      """|val tuple2: (Int, String) = (1, "one")
-          |val list: List[(Int, String)] = List(tuple2)""".stripMargin
-
-    if (actualCount > expectedCount)
-      i"""|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
-      i"""|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 DetachedContext)
-extends SyntaxMsg(IllegalVariableInPatternAlternativeID) {
-  def msg(using Context) = i"Illegal variable $name in pattern alternative"
-  def explain(using Context) = {
-    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
-
-    i"""|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 DetachedContext)
-extends SyntaxMsg(IdentifierExpectedID) {
-  def msg(using Context) = "identifier expected"
-  def explain(using Context) = {
-    val wrongIdentifier = i"def foo: $identifier = {...}"
-    val validIdentifier = i"def foo = {...}"
-    i"""|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()(using DetachedContext)
-extends SyntaxMsg(AuxConstructorNeedsNonImplicitParameterID) {
-  def msg(using Context) = "Auxiliary constructor needs non-implicit parameter list"
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-extends SyntaxMsg(IllegalLiteralID) {
-  def msg(using Context) = "Illegal literal"
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-extends Message(LossyWideningConstantConversionID):
-  def kind = MessageKind.LossyConversion
-  def msg(using Context) = i"""|Widening conversion from $sourceType to $targetType loses precision.
-                |Write `.to$targetType` instead."""
-  def explain(using Context) = ""
-
-class PatternMatchExhaustivity(uncoveredFn: -> String, hasMore: Boolean)(using DetachedContext)
-extends Message(PatternMatchExhaustivityID) {
-  def kind = MessageKind.PatternMatchExhaustivity
-  lazy val uncovered = uncoveredFn
-  def msg(using Context) =
-    val addendum = if hasMore then "(More unmatched cases are elided)" else ""
-    i"""|${hl("match")} may not be exhaustive.
-        |
-        |It would fail on pattern case: $uncovered
-        |$addendum"""
-
-
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-  extends PatternMatchMsg(UncheckedTypePatternID) {
-  def msg(using Context) = msgFn
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-extends Message(MatchCaseUnreachableID) {
-  def kind = MessageKind.MatchCaseUnreachable
-  def msg(using Context) = "Unreachable case"
-  def explain(using Context) = ""
-}
-
-class MatchCaseOnlyNullWarning()(using DetachedContext)
-extends PatternMatchMsg(MatchCaseOnlyNullWarningID) {
-  def msg(using Context) = i"""Unreachable case except for ${hl("null")} (if this is intentional, consider writing ${hl("case null =>")} instead)."""
-  def explain(using Context) = ""
-}
-
-class MatchableWarning(tp: Type, pattern: Boolean)(using DetachedContext)
-extends TypeMsg(MatchableWarningID) {
-  def msg(using Context) =
-    val kind = if pattern then "pattern selector" else "value"
-    i"""${kind} should be an instance of Matchable,
-       |but it has unmatchable type $tp instead"""
-
-  def explain(using Context) =
-    if pattern then
-      i"""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
-      i"""The value can be converted to a `Matchable` by appending `.asMatchable`.
-         |`asMatchable` needs to be imported from scala.compiletime."""
-}
-
-class SeqWildcardPatternPos()(using DetachedContext)
-extends SyntaxMsg(SeqWildcardPatternPosID) {
-  def msg(using Context) = i"""${hl("*")} can be used only for last argument"""
-  def explain(using Context) = {
-    val code =
-      """def sumOfTheFirstTwo(list: List[Int]): Int = list match {
-        |  case List(first, second, x*) => first + second
-        |  case _ => 0
-        |}"""
-    i"""|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 DetachedContext)
-extends SyntaxMsg(IllegalStartOfSimplePatternID) {
-  def msg(using Context) = "pattern expected"
-  def explain(using Context) = {
-    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
-        |}"""
-    i"""|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 DetachedContext)
-extends NamingMsg(PkgDuplicateSymbolID) {
-  def msg(using Context) = i"Trying to define package with same name as $existing"
-  def explain(using Context) = ""
-}
-
-class ExistentialTypesNoLongerSupported()(using DetachedContext)
-extends SyntaxMsg(ExistentialTypesNoLongerSupportedID) {
-  def msg(using Context) =
-    i"""|Existential types are no longer supported -
-        |use a wildcard or dependent type instead"""
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-extends SyntaxMsg(UnboundWildcardTypeID) {
-  def msg(using Context) = "Unbound wildcard type"
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-extends DeclarationMsg(OverridesNothingID) {
-  def msg(using Context) = i"""${member} overrides nothing"""
-
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-extends DeclarationMsg(OverridesNothingButNameExistsID) {
-  def msg(using Context) =
-    val what =
-      if !existing.exists(_.symbol.hasTargetName(member.targetName))
-      then "target name"
-      else "signature"
-    i"""${member} has a different $what than the overridden declaration"""
-  def explain(using Context) =
-    val existingDecl: String = existing.map(_.showDcl).mkString("  \n")
-    i"""|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(
-    core: Context ?-> String, base: Type,
-    member: Symbol, other: Symbol,
-    memberTp: Type, otherTp: Type)(using DetachedContext)
-extends DeclarationMsg(OverrideErrorID), NoDisambiguation:
-  def msg(using Context) =
-    val isConcreteOverAbstract =
-      (other.owner isSubClass member.owner) && other.is(Deferred) && !member.is(Deferred)
-    def addendum =
-      if isConcreteOverAbstract then
-        i"""|
-            |(Note that ${err.infoStringWithLocation(other, base)} is abstract,
-            |and is therefore overridden by concrete ${err.infoStringWithLocation(member, base)})"""
-        else ""
-    i"""error overriding ${err.infoStringWithLocation(other, base)};
-        |  ${err.infoString(member, base, showLocation = member.owner != base.typeSymbol)} $core$addendum"""
-  override def canExplain =
-    memberTp.exists && otherTp.exists
-  def explain(using Context) =
-    if canExplain then err.whyNoMatchStr(memberTp, otherTp) else ""
-
-class ForwardReferenceExtendsOverDefinition(value: Symbol, definition: Symbol)(using DetachedContext)
-extends ReferenceMsg(ForwardReferenceExtendsOverDefinitionID) {
-  def msg(using Context) = i"${definition.name} is a forward reference extending over the definition of ${value.name}"
-
-  def explain(using Context) =
-    i"""|${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.
-        |"""
-}
-
-class ExpectedTokenButFound(expected: Token, found: Token)(using DetachedContext)
-extends SyntaxMsg(ExpectedTokenButFoundID) {
-
-  private def foundText = Tokens.showToken(found)
-
-  def msg(using Context) =
-    val expectedText =
-      if (Tokens.isIdentifier(expected)) "an identifier"
-      else Tokens.showToken(expected)
-    i"""${expectedText} expected, but ${foundText} found"""
-
-  def explain(using Context) =
-    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 DetachedContext)
-extends SyntaxMsg(MixedLeftAndRightAssociativeOpsID) {
-  def msg(using Context) =
-    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"
-    i"${op1} (${op1Asso}) and ${op2} ($op2Asso) have same precedence and may not be mixed"
-  def explain(using Context) =
-    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 DetachedContext)
-extends TypeMsg(CantInstantiateAbstractClassOrTraitID) {
-  private val traitOrAbstract = if (isTrait) "a trait" else "abstract"
-  def msg(using Context) = i"""${cls.name} is ${traitOrAbstract}; it cannot be instantiated"""
-  def explain(using Context) =
-    i"""|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.
-        |"""
-}
-
-class UnreducibleApplication(tycon: Type)(using DetachedContext) extends TypeMsg(UnreducibleApplicationID):
-  def msg(using Context) = i"unreducible application of higher-kinded type $tycon to wildcard arguments"
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-extends CyclicMsg(OverloadedOrRecursiveMethodNeedsResultTypeID) {
-  def msg(using Context) = i"""Overloaded or recursive $cycleSym needs return type"""
-  def explain(using Context) =
-    i"""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.
-        |"""
-}
-
-class RecursiveValueNeedsResultType(cycleSym: Symbol)(using DetachedContext)
-extends CyclicMsg(RecursiveValueNeedsResultTypeID) {
-  def msg(using Context) = i"""Recursive $cycleSym needs type"""
-  def explain(using Context) =
-    i"""The definition of $cycleSym is recursive and you need to specify its type.
-        |"""
-}
-
-class CyclicReferenceInvolving(denot: SymDenotation)(using DetachedContext)
-extends CyclicMsg(CyclicReferenceInvolvingID) {
-  def msg(using Context) =
-    val where = if denot.exists then s" involving $denot" else ""
-    i"Cyclic reference$where"
-  def explain(using Context) =
-    i"""|$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.
-        |"""
-}
-
-class CyclicReferenceInvolvingImplicit(cycleSym: Symbol)(using DetachedContext)
-extends CyclicMsg(CyclicReferenceInvolvingImplicitID) {
-  def msg(using Context) = i"""Cyclic reference involving implicit $cycleSym"""
-  def explain(using Context) =
-    i"""|$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.
-        |"""
-}
-
-class SkolemInInferred(tree: tpd.Tree, pt: Type, argument: tpd.Tree)(using DetachedContext)
-extends TypeMsg(SkolemInInferredID):
-  def msg(using Context) =
-    def argStr =
-      if argument.isEmpty then ""
-      else i" from argument of type ${argument.tpe.widen}"
-    i"""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(using Context) =
-    i"""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 DetachedContext)
-extends ReferenceMsg(SuperQualMustBeParentID) {
-  def msg(using Context) = i"""|$qual does not name a parent of $cls"""
-  def explain(using Context) =
-    val parents: Seq[String] = (cls.info.parents map (_.typeSymbol.name.show)).sorted
-    i"""|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  - ", "")}
-        |"""
-}
-
-class VarArgsParamMustComeLast()(using DetachedContext)
-extends SyntaxMsg(VarArgsParamMustComeLastID) {
-  def msg(using Context) = i"""${hl("varargs")} parameter must come last"""
-  def explain(using Context) =
-    i"""|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: DetachedContext)(using DetachedContext)
-  extends ReferenceMsg(AmbiguousReferenceID), NoDisambiguation {
-
-  /** 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 = "")(using DetachedContext) = {
-    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) {
-      i"""$howVisible$qualifier by ${whereFound.importInfo}"""
-    } else
-      i"""$howVisible$qualifier in ${whereFound.owner}"""
-  }
-
-  def msg(using Context) =
-    i"""|Reference to $name is ambiguous,
-        |it is both ${bindingString(newPrec, ctx)}
-        |and ${bindingString(prevPrec, prevCtx, " subsequently")}"""
-
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-extends TypeMsg(MethodDoesNotTakeParametersId) {
-  def methodSymbol(using Context): 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(using Context) = {
-    val more = if (tree.isInstanceOf[tpd.Apply]) " more" else ""
-    val meth = methodSymbol
-    val methStr = if (meth.exists) meth.showLocated else "expression"
-    i"$methStr does not take$more parameters"
-  }
-
-  def explain(using Context) = {
-    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 = "")(
-  using DetachedContext)
-extends ReferenceMsg(AmbiguousOverloadID), NoDisambiguation {
-  private def all = if (alternatives.length == 2) "both" else "all"
-  def msg(using Context) =
-    i"""|Ambiguous overload. The ${err.overloadedAltsStr(alternatives)}
-        |$all match ${err.expectedTypeStr(pt)}$addendum"""
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-  extends TypeMsg(ReassignmentToValID) {
-  def msg(using Context) = i"""Reassignment to val $name"""
-  def explain(using Context) =
-    i"""|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("=")} ...
-        |"""
-}
-
-class TypeDoesNotTakeParameters(tpe: Type, params: List[untpd.Tree])(using DetachedContext)
-  extends TypeMsg(TypeDoesNotTakeParametersID) {
-  private def fboundsAddendum(using Context) =
-    if tpe.typeSymbol.isAllOf(Provisional | TypeParam) then
-      "\n(Note that F-bounds of type parameters may not be type lambdas)"
-    else ""
-  def msg(using Context) = i"$tpe does not take type parameters$fboundsAddendum"
-  def explain(using Context) =
-    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 $tpe, which is not
-        |declared to take any.
-        |"""
-}
-
-class VarValParametersMayNotBeCallByName(name: TermName, mutable: Boolean)(using DetachedContext)
-  extends SyntaxMsg(VarValParametersMayNotBeCallByNameID) {
-  def varOrVal = if mutable then hl("var") else hl("val")
-  def msg(using Context) = s"$varOrVal parameters may not be call-by-name"
-  def explain(using Context) =
-    i"""${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 DetachedContext)
-  extends SyntaxMsg(MissingTypeParameterForID) {
-  def msg(using Context) =
-    if tpe.derivesFrom(defn.AnyKindClass)
-    then i"$tpe cannot be used as a value type"
-    else i"Missing type parameter for $tpe"
-  def explain(using Context) = ""
-}
-
-class MissingTypeParameterInTypeApp(tpe: Type)(using DetachedContext)
-  extends TypeMsg(MissingTypeParameterInTypeAppID) {
-  def numParams = tpe.typeParams.length
-  def parameters = if (numParams == 1) "parameter" else "parameters"
-  def msg(using Context) = i"Missing type $parameters for $tpe"
-  def explain(using Context) = i"A fully applied type is expected but $tpe takes $numParams $parameters"
-}
-
-class MissingArgument(pname: Name, methString: String)(using DetachedContext)
-  extends TypeMsg(MissingArgumentID):
-  def msg(using Context) =
-    if pname.firstPart contains '$' then s"not enough arguments for $methString"
-    else s"missing argument for parameter $pname of $methString"
-  def explain(using Context) = ""
-
-class DoesNotConformToBound(tpe: Type, which: String, bound: Type)(using DetachedContext)
-  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(using Context) =
-    if isBounds then
-      i"Type argument ${tpe} does not overlap with $which bound $bound"
-    else
-      i"Type argument ${tpe} does not conform to $which bound $bound"
-
-class DoesNotConformToSelfType(category: String, selfType: Type, cls: Symbol,
-                                otherSelf: Type, relation: String, other: Symbol)(
-  using DetachedContext)
-  extends TypeMismatchMsg(selfType, otherSelf)(DoesNotConformToSelfTypeID) {
-  def msg(using Context) = i"""$category: self type $selfType of $cls does not conform to self type $otherSelf
-                |of $relation $other"""
-}
-
-class DoesNotConformToSelfTypeCantBeInstantiated(tp: Type, selfType: Type)(
-  using DetachedContext)
-  extends TypeMismatchMsg(tp, selfType)(DoesNotConformToSelfTypeCantBeInstantiatedID) {
-  def msg(using Context) = i"""$tp does not conform to its self type $selfType; cannot be instantiated"""
-}
-
-class IllegalParameterInit(found: Type, expected: Type, param: Symbol, cls: Symbol)(using DetachedContext)
-  extends TypeMismatchMsg(found, expected)(IllegalParameterInitID):
-  def msg(using Context) =
-    i"""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)(
-  using DetachedContext)
-  extends SyntaxMsg(AbstractMemberMayNotHaveModifierID) {
-  def msg(using Context) = i"""${hl("abstract")} $sym may not have `${flag.flagsString}` modifier"""
-  def explain(using Context) = ""
-}
-
-class TypesAndTraitsCantBeImplicit()(using DetachedContext)
-  extends SyntaxMsg(TypesAndTraitsCantBeImplicitID) {
-  def msg(using Context) = i"""${hl("implicit")} modifier cannot be used for types or traits"""
-  def explain(using Context) = ""
-}
-
-class OnlyClassesCanBeAbstract(sym: Symbol)(
-  using DetachedContext)
-  extends SyntaxMsg(OnlyClassesCanBeAbstractID) {
-  def explain(using Context) = ""
-  def msg(using Context) = i"""${hl("abstract")} modifier can be used only for classes; it should be omitted for abstract members"""
-}
-
-class AbstractOverrideOnlyInTraits(sym: Symbol)(
-  using DetachedContext)
-  extends SyntaxMsg(AbstractOverrideOnlyInTraitsID) {
-  def msg(using Context) = i"""${hl("abstract override")} modifier only allowed for members of traits"""
-  def explain(using Context) = ""
-}
-
-class TraitsMayNotBeFinal(sym: Symbol)(
-  using DetachedContext)
-  extends SyntaxMsg(TraitsMayNotBeFinalID) {
-  def msg(using Context) = i"""$sym may not be ${hl("final")}"""
-  def explain(using Context) =
-    "A trait can never be final since it is abstract and must be extended to be useful."
-}
-
-class NativeMembersMayNotHaveImplementation(sym: Symbol)(
-  using DetachedContext)
-  extends SyntaxMsg(NativeMembersMayNotHaveImplementationID) {
-  def msg(using Context) = i"""${hl("@native")} members may not have an implementation"""
-  def explain(using Context) = ""
-}
-
-class TraitMayNotDefineNativeMethod(sym: Symbol)(
-  using DetachedContext)
-  extends SyntaxMsg(TraitMayNotDefineNativeMethodID) {
-  def msg(using Context) = i"""A trait cannot define a ${hl("@native")} method."""
-  def explain(using Context) = ""
-}
-
-class OnlyClassesCanHaveDeclaredButUndefinedMembers(sym: Symbol)(
-  using DetachedContext)
-  extends SyntaxMsg(OnlyClassesCanHaveDeclaredButUndefinedMembersID) {
-
-  def msg(using Context) = i"""Declaration of $sym not allowed here: only classes can have declared but undefined members"""
-  def explain(using Context) =
-    if sym.is(Mutable) then "Note that variables need to be initialized to be defined."
-    else ""
-}
-
-class CannotExtendAnyVal(sym: Symbol)(using DetachedContext)
-  extends SyntaxMsg(CannotExtendAnyValID) {
-  def msg(using Context) = i"""$sym cannot extend ${hl("AnyVal")}"""
-  def explain(using Context) =
-    i"""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 DetachedContext)
-  extends SyntaxMsg(CannotExtendJavaEnumID) {
-    def msg(using Context) = i"""$sym cannot extend ${hl("java.lang.Enum")}: only enums defined with the ${hl("enum")} syntax can"""
-    def explain(using Context) = ""
-  }
-
-class CannotExtendContextFunction(sym: Symbol)(using DetachedContext)
-  extends SyntaxMsg(CannotExtendFunctionID) {
-    def msg(using Context) = i"""$sym cannot extend a context function class"""
-    def explain(using Context) = ""
-  }
-
-class JavaEnumParentArgs(parent: Type)(using DetachedContext)
-  extends TypeMsg(JavaEnumParentArgsID) {
-    def msg(using Context) = i"""not enough arguments for constructor Enum: ${hl("(name: String, ordinal: Int)")}: ${hl(parent.show)}"""
-    def explain(using Context) = ""
-  }
-
-class CannotHaveSameNameAs(sym: Symbol, cls: Symbol, reason: CannotHaveSameNameAs.Reason)(using DetachedContext)
-  extends NamingMsg(CannotHaveSameNameAsID) {
-  import CannotHaveSameNameAs._
-  def reasonMessage(using Context): 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(using Context) = i"""$sym cannot have the same name as ${cls.showLocated} -- """ + reasonMessage
-  def explain(using Context) = ""
-}
-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 DetachedContext)
-  extends SyntaxMsg(ValueClassesMayNotDefineInnerID) {
-  def msg(using Context) = i"""Value classes may not define an inner class"""
-  def explain(using Context) = ""
-}
-
-class ValueClassesMayNotDefineNonParameterField(valueClass: Symbol, field: Symbol)(using DetachedContext)
-  extends SyntaxMsg(ValueClassesMayNotDefineNonParameterFieldID) {
-  def msg(using Context) = i"""Value classes may not define non-parameter field"""
-  def explain(using Context) = ""
-}
-
-class ValueClassesMayNotDefineASecondaryConstructor(valueClass: Symbol, constructor: Symbol)(using DetachedContext)
-  extends SyntaxMsg(ValueClassesMayNotDefineASecondaryConstructorID) {
-  def msg(using Context) = i"""Value classes may not define a secondary constructor"""
-  def explain(using Context) = ""
-}
-
-class ValueClassesMayNotContainInitalization(valueClass: Symbol)(using DetachedContext)
-  extends SyntaxMsg(ValueClassesMayNotContainInitalizationID) {
-  def msg(using Context) = i"""Value classes may not contain initialization statements"""
-  def explain(using Context) = ""
-}
-
-class ValueClassesMayNotBeAbstract(valueClass: Symbol)(using DetachedContext)
-  extends SyntaxMsg(ValueClassesMayNotBeAbstractID) {
-  def msg(using Context) = i"""Value classes may not be ${hl("abstract")}"""
-  def explain(using Context) = ""
-}
-
-class ValueClassesMayNotBeContainted(valueClass: Symbol)(using DetachedContext)
-  extends SyntaxMsg(ValueClassesMayNotBeContaintedID) {
-  private def localOrMember = if (valueClass.owner.isTerm) "local class" else "member of another class"
-  def msg(using Context) = s"""Value classes may not be a $localOrMember"""
-  def explain(using Context) = ""
-}
-
-class ValueClassesMayNotWrapAnotherValueClass(valueClass: Symbol)(using DetachedContext)
-  extends SyntaxMsg(ValueClassesMayNotWrapAnotherValueClassID) {
-  def msg(using Context) = """A value class may not wrap another user-defined value class"""
-  def explain(using Context) = ""
-}
-
-class ValueClassParameterMayNotBeAVar(valueClass: Symbol, param: Symbol)(using DetachedContext)
-  extends SyntaxMsg(ValueClassParameterMayNotBeAVarID) {
-  def msg(using Context) = i"""A value class parameter may not be a ${hl("var")}"""
-  def explain(using Context) =
-    i"""A value class must have exactly one ${hl("val")} parameter."""
-}
-
-class ValueClassNeedsOneValParam(valueClass: Symbol)(using DetachedContext)
-  extends SyntaxMsg(ValueClassNeedsExactlyOneValParamID) {
-  def msg(using Context) = i"""Value class needs one ${hl("val")} parameter"""
-  def explain(using Context) = ""
-}
-
-class ValueClassParameterMayNotBeCallByName(valueClass: Symbol, param: Symbol)(using DetachedContext)
-  extends SyntaxMsg(ValueClassParameterMayNotBeCallByNameID) {
-  def msg(using Context) = s"Value class parameter `${param.name}` may not be call-by-name"
-  def explain(using Context) = ""
-}
-
-class SuperCallsNotAllowedInlineable(symbol: Symbol)(using DetachedContext)
-  extends SyntaxMsg(SuperCallsNotAllowedInlineableID) {
-  def msg(using Context) = i"Super call not allowed in inlineable $symbol"
-  def explain(using Context) = "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 DetachedContext) extends TypeMsg(NotAPathID):
-  def msg(using Context) = i"$tp is not a valid $usage, since it is not an immutable path"
-  def explain(using Context) =
-    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 DetachedContext)
-  extends SyntaxMsg(WrongNumberOfParametersID) {
-  def msg(using Context) = s"Wrong number of parameters, expected: $expected"
-  def explain(using Context) = ""
-}
-
-class DuplicatePrivateProtectedQualifier()(using DetachedContext)
-  extends SyntaxMsg(DuplicatePrivateProtectedQualifierID) {
-  def msg(using Context) = "Duplicate private/protected qualifier"
-  def explain(using Context) =
-    i"It is not allowed to combine `private` and `protected` modifiers even if they are qualified to different scopes"
-}
-
-class ExpectedStartOfTopLevelDefinition()(using DetachedContext)
-  extends SyntaxMsg(ExpectedStartOfTopLevelDefinitionID) {
-  def msg(using Context) = "Expected start of definition"
-  def explain(using Context) =
-    i"You have to provide either ${hl("class")}, ${hl("trait")}, ${hl("object")}, or ${hl("enum")} definitions after qualifiers"
-}
-
-class NoReturnFromInlineable(owner: Symbol)(using DetachedContext)
-  extends SyntaxMsg(NoReturnFromInlineableID) {
-  def msg(using Context) = i"No explicit ${hl("return")} allowed from inlineable $owner"
-  def explain(using Context) =
-    i"""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 DetachedContext)
-  extends SyntaxMsg(ReturnOutsideMethodDefinitionID) {
-  def msg(using Context) = i"${hl("return")} outside method definition"
-  def explain(using Context) =
-    i"""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 DetachedContext)
-  extends SyntaxMsg(ExtendFinalClassID) {
-  def msg(using Context) = i"$clazz cannot extend ${hl("final")} $finalClazz"
-  def explain(using Context) =
-    i"""A class marked with the ${hl("final")} keyword cannot be extended"""
-}
-
-class ExpectedTypeBoundOrEquals(found: Token)(using DetachedContext)
-  extends SyntaxMsg(ExpectedTypeBoundOrEqualsID) {
-  def msg(using Context) = i"${hl("=")}, ${hl(">:")}, or ${hl("<:")} expected, but ${Tokens.showToken(found)} found"
-
-  def explain(using Context) =
-    i"""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 DetachedContext)
-  extends NamingMsg(ClassAndCompanionNameClashID) {
-  def msg(using Context) =
-    val name = cls.name.stripModuleClassSuffix
-    i"Name clash: both ${cls.owner} and its companion object defines $name"
-  def explain(using Context) =
-    i"""|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 DetachedContext)
-  extends SyntaxMsg(TailrecNotApplicableID) {
-  def msg(using Context) = {
-    val reason =
-      if !symbol.is(Method) then i"$symbol isn't a method"
-      else if symbol.is(Deferred) then i"$symbol is abstract"
-      else if !symbol.isEffectivelyFinal then i"$symbol is neither ${hl("private")} nor ${hl("final")} so can be overridden"
-      else i"$symbol contains no recursive calls"
-
-    s"TailRec optimisation not applicable, $reason"
-  }
-  def explain(using Context) = ""
-}
-
-class FailureToEliminateExistential(tp: Type, tp1: Type, tp2: Type, boundSyms: List[Symbol], classRoot: Symbol)(using DetachedContext)
-  extends Message(FailureToEliminateExistentialID) {
-  def kind = MessageKind.Compatibility
-  def msg(using Context) =
-    val originalType = ctx.printer.dclsText(boundSyms, "; ").show
-    i"""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(using Context) =
-    i"""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 DetachedContext)
-  extends SyntaxMsg(OnlyFunctionsCanBeFollowedByUnderscoreID) {
-  def msg(using Context) = i"Only function types can be followed by ${hl("_")} but the current expression has type $tp"
-  def explain(using Context) =
-    i"""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 DetachedContext)
-  extends SyntaxMsg(MissingEmptyArgumentListID) {
-  def msg(using Context) = i"$method must be called with ${hl("()")} argument"
-  def explain(using Context) = {
-    val codeExample =
-      """def next(): T = ...
-        |next     // is expanded to next()"""
-
-    i"""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 DetachedContext)
-  extends SyntaxMsg(DuplicateNamedTypeParameterID) {
-  def msg(using Context) = i"Type parameter $name was defined multiple times."
-  def explain(using Context) = ""
-}
-
-class UndefinedNamedTypeParameter(undefinedName: Name, definedNames: List[Name])(using DetachedContext)
-  extends SyntaxMsg(UndefinedNamedTypeParameterID) {
-  def msg(using Context) = i"Type parameter $undefinedName is undefined. Expected one of ${definedNames.map(_.show).mkString(", ")}."
-  def explain(using Context) = ""
-}
-
-class IllegalStartOfStatement(what: String, isModifier: Boolean, isStat: Boolean)(using DetachedContext) extends SyntaxMsg(IllegalStartOfStatementID) {
-  def msg(using Context) =
-    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(using Context) =
-    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 DetachedContext) extends SyntaxMsg(TraitIsExpectedID) {
-  def msg(using Context) = i"$symbol is not a trait"
-  def explain(using Context) = {
-    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
-
-    i"""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 DetachedContext) extends SyntaxMsg(TraitRedefinedFinalMethodFromAnyRefID) {
-  def msg(using Context) = i"Traits cannot redefine final $method from ${hl("class AnyRef")}."
-  def explain(using Context) = ""
-}
-
-class AlreadyDefined(name: Name, owner: Symbol, conflicting: Symbol)(using DetachedContext)
-extends NamingMsg(AlreadyDefinedID):
-  def msg(using Context) =
-    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}"
-    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 ""
-    if conflicting.isTerm != name.isTermName then
-      i"$name clashes with $conflicting$where; the two must be defined together"
-    else
-      i"$name is already defined as $conflicting$where$note"
-  def explain(using Context) = ""
-
-class PackageNameAlreadyDefined(pkg: Symbol)(using DetachedContext) extends NamingMsg(PackageNameAlreadyDefinedID) {
-  def msg(using Context) =
-    def where = if pkg.associatedFile == null then "" else s" in ${pkg.associatedFile}"
-    i"""${pkg.name} is the name of $pkg$where.
-        |It cannot be used at the same time as the name of a package."""
-  def explain(using Context) =
-    def or = if pkg.associatedFile == null then "" else " or delete the containing class file"
-    i"""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 DetachedContext)
-  extends SyntaxMsg(UnapplyInvalidNumberOfArgumentsID) {
-  def msg(using Context) = i"Wrong number of argument patterns for $qual; expected: ($argTypes%, %)"
-  def explain(using Context) =
-    i"""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%, %).
-        |"""
-}
-
-class UnapplyInvalidReturnType(unapplyResult: Type, unapplyName: Name)(using DetachedContext)
-  extends DeclarationMsg(UnapplyInvalidReturnTypeID) {
-  def msg(using Context) =
-    val addendum =
-      if Feature.migrateTo3 && unapplyName == nme.unapplySeq
-      then "\nYou might want to try to rewrite the extractor to use `unapply` instead."
-      else ""
-    i"""| ${Red(i"$unapplyResult")} is not a valid result type of an $unapplyName method of an ${Magenta("extractor")}.$addendum"""
-  def explain(using Context) = if (unapplyName.show == "unapply")
-    i"""
-        |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
-        |  }
-        |}
-      """
-  else
-    i"""
-        |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!")
-        |  }
-        |}
-      """
-}
-
-class StaticFieldsOnlyAllowedInObjects(member: Symbol)(using DetachedContext) extends SyntaxMsg(StaticFieldsOnlyAllowedInObjectsID) {
-  def msg(using Context) = i"${hl("@static")} $member in ${member.owner} must be defined inside a static ${hl("object")}."
-  def explain(using Context) =
-    i"${hl("@static")} members are only allowed inside objects."
-}
-
-class StaticFieldsShouldPrecedeNonStatic(member: Symbol, defns: List[tpd.Tree])(using DetachedContext) extends SyntaxMsg(StaticFieldsShouldPrecedeNonStaticID) {
-  def msg(using Context) = i"${hl("@static")} $member in ${member.owner} must be defined before non-static fields."
-  def explain(using Context) = {
-    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  ")}
-                      |  ...
-                      |}"""
-    i"""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 DetachedContext) extends SyntaxMsg(CyclicInheritanceID) {
-  def msg(using Context) = i"Cyclic inheritance: $symbol extends itself$addendum"
-  def explain(using Context) = {
-    val codeExample = "class A extends A"
-
-    i"""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 DetachedContext)
-extends ReferenceMsg(BadSymbolicReferenceID) {
-  def msg(using Context) = {
-    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")
-
-    i"""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(using Context) = ""
-}
-
-class UnableToExtendSealedClass(pclazz: Symbol)(using DetachedContext) extends SyntaxMsg(UnableToExtendSealedClassID) {
-  def msg(using Context) = i"Cannot extend ${hl("sealed")} $pclazz in a different source file"
-  def explain(using Context) = "A sealed class or trait can only be extended in the same file as its declaration"
-}
-
-class SymbolHasUnparsableVersionNumber(symbol: Symbol, errorMessage: String)(using DetachedContext)
-extends SyntaxMsg(SymbolHasUnparsableVersionNumberID) {
-  def msg(using Context) = i"${symbol.showLocated} has an unparsable version number: $errorMessage"
-  def explain(using Context) =
-    i"""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 DetachedContext) extends SyntaxMsg(SymbolChangedSemanticsInVersionID) {
-  def msg(using Context) = i"${symbol.showLocated} has changed semantics in version $migrationVersion: $migrationMessage"
-  def explain(using Context) =
-    i"""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 DetachedContext)
-extends SyntaxMsg(UnableToEmitSwitchID) {
-  def msg(using Context) = i"Could not emit switch for ${hl("@switch")} annotated match"
-  def explain(using Context) = {
-    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
-
-    i"""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 DetachedContext)
-extends SyntaxMsg(MissingCompanionForStaticID) {
-  def msg(using Context) = i"${member.owner} does not have a companion class"
-  def explain(using Context) =
-    i"An object that contains ${hl("@static")} members must have a companion class."
-}
-
-class PolymorphicMethodMissingTypeInParent(rsym: Symbol, parentSym: Symbol)(using DetachedContext)
-extends SyntaxMsg(PolymorphicMethodMissingTypeInParentID) {
-  def msg(using Context) = i"Polymorphic refinement $rsym without matching type in parent $parentSym is no longer allowed"
-  def explain(using Context) =
-    i"""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 DetachedContext)
-  extends SyntaxMsg(ParamsNoInlineID) {
-  def msg(using Context) = i"""${hl("inline")} modifier can only be used for parameters of inline methods"""
-  def explain(using Context) = ""
-}
-
-class JavaSymbolIsNotAValue(symbol: Symbol)(using DetachedContext) extends TypeMsg(JavaSymbolIsNotAValueID) {
-  def msg(using Context) =
-    val kind =
-      if symbol is Package then i"$symbol"
-      else i"Java defined ${hl("class " + symbol.name)}"
-    s"$kind is not a value"
-  def explain(using Context) = ""
-}
-
-class DoubleDefinition(decl: Symbol, previousDecl: Symbol, base: Symbol)(using DetachedContext)
-extends NamingMsg(DoubleDefinitionID) {
-  def msg(using Context) = {
-    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) {
-      i"""$clashDescription:
-          |${previousDecl.showDcl} ${symLocation(previousDecl)} and
-          |${decl.showDcl} ${symLocation(decl)}
-          |"""
-    } + details
-  }
-  def explain(using Context) = ""
-}
-
-class ImportRenamedTwice(ident: untpd.Ident)(using DetachedContext) extends SyntaxMsg(ImportRenamedTwiceID) {
-  def msg(using Context) = s"${ident.show} is renamed twice on the same import line."
-  def explain(using Context) = ""
-}
-
-class TypeTestAlwaysDiverges(scrutTp: Type, testTp: Type)(using DetachedContext) extends SyntaxMsg(TypeTestAlwaysDivergesID) {
-  def msg(using Context) =
-    s"This type test will never return a result since the scrutinee type ${scrutTp.show} does not contain any value."
-  def explain(using Context) = ""
-}
-
-// Relative of CyclicReferenceInvolvingImplicit and RecursiveValueNeedsResultType
-class TermMemberNeedsResultTypeForImplicitSearch(cycleSym: Symbol)(using DetachedContext)
-  extends CyclicMsg(TermMemberNeedsNeedsResultTypeForImplicitSearchID) {
-  def msg(using Context) = i"""$cycleSym needs result type because its right-hand side attempts implicit search"""
-  def explain(using Context) =
-    i"""|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.
-        |"""
-}
-
-class ClassCannotExtendEnum(cls: Symbol, parent: Symbol)(using DetachedContext) extends SyntaxMsg(ClassCannotExtendEnumID) {
-  def msg(using Context) = i"""$cls in ${cls.owner} extends enum ${parent.name}, but extending enums is prohibited."""
-  def explain(using Context) = ""
-}
-
-class NotAnExtractor(tree: untpd.Tree)(using DetachedContext) extends SyntaxMsg(NotAnExtractorID) {
-  def msg(using Context) = i"$tree cannot be used as an extractor in a pattern because it lacks an unapply or unapplySeq method"
-  def explain(using Context) =
-    i"""|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)")}"""
-}
-
-class MemberWithSameNameAsStatic()(using DetachedContext)
-  extends SyntaxMsg(MemberWithSameNameAsStaticID) {
-  def msg(using Context) = i"Companion classes cannot define members with same name as a ${hl("@static")} member"
-  def explain(using Context) = ""
-}
-
-class PureExpressionInStatementPosition(stat: untpd.Tree, val exprOwner: Symbol)(using DetachedContext)
-  extends Message(PureExpressionInStatementPositionID) {
-  def kind = MessageKind.PotentialIssue
-  def msg(using Context) = "A pure expression does nothing in statement position; you may be omitting necessary parentheses"
-  def explain(using Context) =
-    i"""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."""
-}
-
-class TraitCompanionWithMutableStatic()(using DetachedContext)
-  extends SyntaxMsg(TraitCompanionWithMutableStaticID) {
-  def msg(using Context) = i"Companion of traits cannot define mutable @static fields"
-  def explain(using Context) = ""
-}
-
-class LazyStaticField()(using DetachedContext)
-  extends SyntaxMsg(LazyStaticFieldID) {
-  def msg(using Context) = i"Lazy @static fields are not supported"
-  def explain(using Context) = ""
-}
-
-class StaticOverridingNonStaticMembers()(using DetachedContext)
-  extends SyntaxMsg(StaticOverridingNonStaticMembersID) {
-  def msg(using Context) = i"${hl("@static")} members cannot override or implement non-static ones"
-  def explain(using Context) = ""
-}
-
-class OverloadInRefinement(rsym: Symbol)(using DetachedContext)
-  extends DeclarationMsg(OverloadInRefinementID) {
-  def msg(using Context) = "Refinements cannot introduce overloaded definitions"
-  def explain(using Context) =
-    i"""The refinement `$rsym` introduces an overloaded definition.
-        |Refinements cannot contain overloaded definitions."""
-}
-
-class NoMatchingOverload(val alternatives: List[SingleDenotation], pt: Type)(using DetachedContext)
-  extends TypeMsg(NoMatchingOverloadID) {
-  def msg(using Context) =
-    i"""None of the ${err.overloadedAltsStr(alternatives)}
-        |match ${err.expectedTypeStr(pt)}"""
-  def explain(using Context) = ""
-}
-class StableIdentPattern(tree: untpd.Tree, pt: Type)(using DetachedContext)
-  extends TypeMsg(StableIdentPatternID) {
-  def msg(using Context) =
-    i"""Stable identifier required, but $tree found"""
-  def explain(using Context) = ""
-}
-
-class IllegalSuperAccessor(base: Symbol, memberName: Name, targetName: Name,
-    acc: Symbol, accTp: Type,
-    other: Symbol, otherTp: Type)(using DetachedContext) extends DeclarationMsg(IllegalSuperAccessorID) {
-  def msg(using Context) = {
-    // 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")
-    }
-    i"""$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
-       |"""
-  }
-  def explain(using Context) = ""
-}
-
-class TraitParameterUsedAsParentPrefix(cls: Symbol)(using DetachedContext)
-  extends DeclarationMsg(TraitParameterUsedAsParentPrefixID) {
-  def msg(using Context) =
-    s"${cls.show} cannot extend from a parent that is derived via its own parameters"
-  def explain(using Context) =
-    i"""
-       |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}.
-       |"""
-}
-
-class UnknownNamedEnclosingClassOrObject(name: TypeName)(using DetachedContext)
-  extends ReferenceMsg(UnknownNamedEnclosingClassOrObjectID) {
-  def msg(using Context) =
-    i"""no enclosing class or object is named '${hl(name.show)}'"""
-  def explain(using Context) =
-    i"""
-    |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.
-    """
-  }
-
-class IllegalCyclicTypeReference(sym: Symbol, where: String, lastChecked: Type)(using DetachedContext)
-  extends CyclicMsg(IllegalCyclicTypeReferenceID) {
-  def msg(using Context) =
-    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(using Context) = ""
-}
-
-class ErasedTypesCanOnlyBeFunctionTypes()(using DetachedContext)
-  extends SyntaxMsg(ErasedTypesCanOnlyBeFunctionTypesID) {
-  def msg(using Context) = "Types with erased keyword can only be function types `(erased ...) => ...`"
-  def explain(using Context) = ""
-}
-
-class CaseClassMissingNonImplicitParamList(cdef: untpd.TypeDef)(using DetachedContext)
-  extends SyntaxMsg(CaseClassMissingNonImplicitParamListID) {
-  def msg(using Context) =
-    i"""|A ${hl("case class")} must have at least one leading non-implicit parameter list"""
-
-  def explain(using Context) =
-    i"""|${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}."""
-}
-
-class EnumerationsShouldNotBeEmpty(cdef: untpd.TypeDef)(using DetachedContext)
-  extends SyntaxMsg(EnumerationsShouldNotBeEmptyID) {
-  def msg(using Context) = "Enumerations must contain at least one case"
-
-  def explain(using Context) =
-    i"""|Enumeration ${cdef.name} must contain at least one case
-        |Example Usage:
-        | ${hl("enum")} ${cdef.name} {
-        |    ${hl("case")} Option1, Option2
-        | }
-        |"""
-}
-
-class TypedCaseDoesNotExplicitlyExtendTypedEnum(enumDef: Symbol, caseDef: untpd.TypeDef)(using DetachedContext)
-  extends SyntaxMsg(TypedCaseDoesNotExplicitlyExtendTypedEnumID) {
-  def msg(using Context) = i"explicit extends clause needed because both enum case and enum class have type parameters"
-
-  def explain(using Context) =
-    i"""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]
-        | }
-        |"""
-}
-
-class IllegalRedefinitionOfStandardKind(kindType: String, name: Name)(using DetachedContext)
-  extends SyntaxMsg(IllegalRedefinitionOfStandardKindID) {
-  def msg(using Context) = i"illegal redefinition of standard $kindType $name"
-  def explain(using Context) =
-    i"""| "$name" is a standard Scala core `$kindType`
-        | Please choose a different name to avoid conflicts
-        |"""
-}
-
-class NoExtensionMethodAllowed(mdef: untpd.DefDef)(using DetachedContext)
-  extends SyntaxMsg(NoExtensionMethodAllowedID) {
-  def msg(using Context) = i"No extension method allowed here, since collective parameters are given"
-  def explain(using Context) =
-    i"""|Extension method:
-        |  `${mdef}`
-        |is defined inside an extension clause which has collective parameters.
-        |"""
-}
-
-class ExtensionMethodCannotHaveTypeParams(mdef: untpd.DefDef)(using DetachedContext)
-  extends SyntaxMsg(ExtensionMethodCannotHaveTypeParamsID) {
-  def msg(using Context) = i"Extension method cannot have type parameters since some were already given previously"
-
-  def explain(using Context) =
-    i"""|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.
-        |"""
-}
-
-class ExtensionCanOnlyHaveDefs(mdef: untpd.Tree)(using DetachedContext)
-  extends SyntaxMsg(ExtensionCanOnlyHaveDefsID) {
-  def msg(using Context) = i"Only methods allowed here, since collective parameters are given"
-  def explain(using Context) =
-    i"""Extension clauses can only have `def`s
-        | `${mdef.show}` is not a valid expression here.
-        |"""
-}
-
-class UnexpectedPatternForSummonFrom(tree: Tree[_])(using DetachedContext)
-  extends SyntaxMsg(UnexpectedPatternForSummonFromID) {
-  def msg(using Context) = i"Unexpected pattern for summonFrom. Expected ${hl("`x: T`")} or ${hl("`_`")}"
-  def explain(using Context) =
-    i"""|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 _ => ???
-        | }
-        |"""
-}
-
-class AnonymousInstanceCannotBeEmpty(impl:  untpd.Template)(using DetachedContext)
-  extends SyntaxMsg(AnonymousInstanceCannotBeEmptyID) {
-  def msg(using Context) = i"anonymous instance must implement a type or have at least one extension method"
-  def explain(using Context) =
-    i"""|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.
-        |"""
-}
-
-class ModifierNotAllowedForDefinition(flag: Flag)(using DetachedContext)
-  extends SyntaxMsg(ModifierNotAllowedForDefinitionID) {
-  def msg(using Context) = i"Modifier ${hl(flag.flagsString)} is not allowed for this definition"
-  def explain(using Context) = ""
-}
-
-class RedundantModifier(flag: Flag)(using DetachedContext)
-  extends SyntaxMsg(RedundantModifierID) {
-  def msg(using Context) = i"Modifier ${hl(flag.flagsString)} is redundant for this definition"
-  def explain(using Context) = ""
-}
-
-class InvalidReferenceInImplicitNotFoundAnnotation(typeVar: String, owner: String)(using DetachedContext)
-  extends ReferenceMsg(InvalidReferenceInImplicitNotFoundAnnotationID) {
-  def msg(using Context) = i"""|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)}.
-                |"""
-  def explain(using Context) = ""
-}
-
-class CaseClassInInlinedCode(tree: tpd.Tree)(using DetachedContext)
-  extends SyntaxMsg(CaseClassInInlinedCodeID) {
-
-  def defKind = if tree.symbol.is(Module) then "object" else "class"
-  def msg(using Context) = s"Case $defKind definitions are not allowed in inline methods or quoted code. Use a normal $defKind instead."
-  def explain(using Context) =
-    i"""Case class/object definitions generate a considerable footprint in code size.
-        |Inlining such definition would multiply this footprint for each call site.
-        |"""
-}
-
-class ImplicitSearchTooLargeWarning(limit: Int, openSearchPairs: List[(Candidate, Type)])(using DetachedContext)
-  extends TypeMsg(ImplicitSearchTooLargeID):
-  override def showAlways = true
-  def showQuery(query: (Candidate, Type))(using DetachedContext): String =
-    i"  ${query._1.ref.symbol.showLocated}  for  ${query._2}}"
-  def msg(using Context) =
-    i"""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(using Context) =
-    i"""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 DetachedContext)
-extends SyntaxMsg(TargetNameOnTopLevelClassID):
-  def msg(using Context) = i"${hl("@targetName")} annotation not allowed on top-level $symbol"
-  def explain(using Context) =
-    val annot = symbol.getAnnotation(defn.TargetNameAnnot).get
-    i"""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 DetachedContext)
-extends TypeMsg(NotClassTypeID), ShowMatchTrace(tp):
-  def msg(using Context) = i"$tp is not a class type"
-  def explain(using Context) = ""
-
-class MissingImplicitArgument(
-    arg: tpd.Tree,
-    pt: Type,
-    where: String,
-    paramSymWithMethodCallTree: Option[(Symbol, tpd.Tree)] = None,
-    ignoredInstanceNormalImport: -> Option[SearchSuccess]
-  )(using DetachedContext) extends TypeMsg(MissingImplicitArgumentID), ShowMatchTrace(pt):
-
-  arg.tpe match
-    case ambi: AmbiguousImplicits => withoutDisambiguation()
-    case _ =>
-
-  def msg(using Context): String =
-
-    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`.
-     */
-    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(i"${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`.
-     */
-    def userDefinedMsg(sym: Symbol, cls: Symbol) = for {
-      ann <- sym.getAnnotation(cls)
-      msg <- ann.argumentConstantString(0)
-    } yield msg
-
-    def location(preposition: String) = if (where.isEmpty) "" else s" $preposition $where"
-
-    def defaultAmbiguousImplicitMsg(ambi: AmbiguousImplicits) =
-      s"Ambiguous given instances: ${ambi.explanation}${location("of")}"
-
-    def defaultImplicitNotFoundMessage =
-      i"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`.
-     */
-    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 DetachedContext) =
-        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).detach)
-      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
-     */
-    def formatAnnotationMessage(rawMsg: String, sym: Symbol, substituteType: Type => Type): String = {
-      val substitutableTypesSymbols = 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 = ???
-     */
-    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 = ???
-     */
-    def userDefinedImplicitNotFoundTypeMessage: Option[String] =
-      def recur(tp: Type): Option[String] = tp match
-        case tp: TypeRef =>
-          val sym = tp.symbol
-          userDefinedImplicitNotFoundTypeMessageFor(sym).orElse(recur(tp.info))
-        case tp: ClassInfo =>
-          tp.baseClasses.iterator
-            .map(userDefinedImplicitNotFoundTypeMessageFor)
-            .find(_.isDefined).flatten
-        case tp: TypeProxy =>
-          recur(tp.superType)
-        case tp: AndType =>
-          recur(tp.tp1).orElse(recur(tp.tp2))
-        case _ =>
-          None
-      recur(pt)
-
-    def userDefinedImplicitNotFoundTypeMessageFor(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)
-
-    object AmbiguousImplicitMsg {
-      def unapply(search: SearchSuccess): Option[String] =
-        userDefinedMsg(search.ref.symbol, defn.ImplicitAmbiguousAnnot)
-    }
-
-    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) =>
-        i"""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)()
-  end msg
-
-  override def msgPostscript(using Context) =
-    arg.tpe match
-      case _: AmbiguousImplicits =>
-        ""  // show no disambiguation
-      case _: TooUnspecific =>
-        super.msgPostscript // show just disambigutation and match type trace
-      case _ =>
-        // show all available additional info
-        def hiddenImplicitNote(s: SearchSuccess) =
-          i"\n\nNote: ${s.ref.symbol.showLocated} was not considered because it was not imported with `import given`."
-        super.msgPostscript
-        ++ ignoredInstanceNormalImport.map(hiddenImplicitNote)
-            .getOrElse(ctx.typer.importSuggestionAddendum(pt))
-
-  def explain(using Context) = ""
-end MissingImplicitArgument
-
-class CannotBeAccessed(tpe: NamedType, superAccess: Boolean)(using DetachedContext)
-extends ReferenceMsg(CannotBeAccessedID):
-  def msg(using Context) =
-    val pre = tpe.prefix
-    val name = tpe.name
-    val alts = tpe.denot.alternatives.map(_.symbol).filter(_.exists)
-    val whatCanNot = alts match
-      case Nil =>
-        i"$name cannot"
-      case sym :: Nil =>
-        i"${if (sym.owner == pre.typeSymbol) sym.show else sym.showLocated} cannot"
-      case _ =>
-        i"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))
-    i"$whatCanNot be accessed as a member of $pre$where.$whyNot"
-  def explain(using Context) = ""
-
-
diff --git a/tests/pos-with-compiler-cc/dotc/reporting/trace.scala b/tests/pos-with-compiler-cc/dotc/reporting/trace.scala
deleted file mode 100644
index 528c8bd43502..000000000000
--- a/tests/pos-with-compiler-cc/dotc/reporting/trace.scala
+++ /dev/null
@@ -1,118 +0,0 @@
-package dotty.tools
-package dotc
-package reporting
-
-import scala.language.unsafeNulls
-
-import core.*, Contexts.*, Decorators.*
-import config.*
-import printing.Formatting.*
-
-import scala.compiletime.*
-
-/** 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 =
-    apply(question, printer, {
-      val showOp: T => String = inline if show == true then
-        val showT = summonInline[Show[T]]
-        {
-          given Show[T] = showT
-          t => i"$t"
-        }
-      else
-        summonFrom {
-          case given Show[T] => t => i"$t"
-          case _             => alwaysToString
-        }
-      showOp
-    })(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 val alwaysToString = (x: Any) => String.valueOf(x)
-
-  private def doTrace[T](question: => String,
-                         printer: Printers.Printer = Printers.default,
-                         showOp: T => String)
-                        (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
-      def skipStoreReporter(c: Context): Context = c.reporter match
-        case _: StoreReporter => skipStoreReporter(c.outer)
-        case _ => c
-      val logctx = skipStoreReporter(ctx)
-      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
deleted file mode 100644
index 96e88e5c68ae..000000000000
--- a/tests/pos-with-compiler-cc/dotc/rewrites/Rewrites.scala
+++ /dev/null
@@ -1,102 +0,0 @@
-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
deleted file mode 100644
index aa98f79c8e3b..000000000000
--- a/tests/pos-with-compiler-cc/dotc/sbt/APIUtils.scala
+++ /dev/null
@@ -1,55 +0,0 @@
-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
deleted file mode 100644
index f9cc450d86cd..000000000000
--- a/tests/pos-with-compiler-cc/dotc/sbt/ExtractAPI.scala
+++ /dev/null
@@ -1,833 +0,0 @@
-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 DetachedContext) 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
deleted file mode 100644
index 562e74db6a05..000000000000
--- a/tests/pos-with-compiler-cc/dotc/sbt/ExtractDependencies.scala
+++ /dev/null
@@ -1,504 +0,0 @@
-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: Context ?-> String, pos: SrcPos = NoSourcePosition)(using Context): Unit =
-    report.error(em"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
deleted file mode 100644
index cacb10cf98bc..000000000000
--- a/tests/pos-with-compiler-cc/dotc/sbt/ShowAPI.scala
+++ /dev/null
@@ -1,162 +0,0 @@
-// 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
deleted file mode 100644
index d4ee3dc9a68f..000000000000
--- a/tests/pos-with-compiler-cc/dotc/sbt/ThunkHolder.scala
+++ /dev/null
@@ -1,33 +0,0 @@
-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
deleted file mode 100644
index 379a2e45ce40..000000000000
--- a/tests/pos-with-compiler-cc/dotc/sbt/package.scala
+++ /dev/null
@@ -1,20 +0,0 @@
-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
deleted file mode 100644
index 975d5480fe9b..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/ConstantOps.scala
+++ /dev/null
@@ -1,25 +0,0 @@
-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
deleted file mode 100644
index 2743e37cb79f..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/Descriptor.scala
+++ /dev/null
@@ -1,122 +0,0 @@
-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
deleted file mode 100644
index 4a09b789761b..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/ExtractSemanticDB.scala
+++ /dev/null
@@ -1,517 +0,0 @@
-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 Decorators.collectCC
-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 = inDetachedContext:
-            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.collectCC({
-          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
deleted file mode 100644
index aac4c1254892..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/LinkMode.scala
+++ /dev/null
@@ -1,4 +0,0 @@
-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
deleted file mode 100644
index 6814d923a062..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/PPrint.scala
+++ /dev/null
@@ -1,397 +0,0 @@
-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
deleted file mode 100644
index 00c3ae5dc877..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/Scala3.scala
+++ /dev/null
@@ -1,537 +0,0 @@
-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 core.Decorators.collectCC
-
-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.collectCC {
-              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
deleted file mode 100644
index c7b0dfd437db..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/SemanticSymbolBuilder.scala
+++ /dev/null
@@ -1,152 +0,0 @@
-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(initSym: Symbol): Unit =
-      // revert from the compiler-generated overload of the signature polymorphic method
-      val sym = initSym.originalSignaturePolymorphic.symbol.orElse(initSym)
-      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
deleted file mode 100644
index 50765a172ffd..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/SyntheticsExtractor.scala
+++ /dev/null
@@ -1,151 +0,0 @@
-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
deleted file mode 100644
index d37973237a9f..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/Tools.scala
+++ /dev/null
@@ -1,130 +0,0 @@
-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
deleted file mode 100644
index 52b8343ccb2c..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/TypeOps.scala
+++ /dev/null
@@ -1,527 +0,0 @@
-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 core.Decorators.em
-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(
-      em"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
deleted file mode 100644
index c646e67b69ad..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Access.scala
+++ /dev/null
@@ -1,654 +0,0 @@
-// 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
deleted file mode 100644
index 2cb478d89e2d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Annotation.scala
+++ /dev/null
@@ -1,91 +0,0 @@
-// 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
deleted file mode 100644
index 0ca96d9ae8c6..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Constant.scala
+++ /dev/null
@@ -1,1181 +0,0 @@
-// 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
deleted file mode 100644
index cc8aa82bf8ea..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Diagnostic.scala
+++ /dev/null
@@ -1,196 +0,0 @@
-// 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
deleted file mode 100644
index 07fbda4991af..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Documentation.scala
+++ /dev/null
@@ -1,174 +0,0 @@
-// 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
deleted file mode 100644
index c57a3d3cddc3..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Language.scala
+++ /dev/null
@@ -1,56 +0,0 @@
-// 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
deleted file mode 100644
index a3667e944ae4..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Location.scala
+++ /dev/null
@@ -1,109 +0,0 @@
-// 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
deleted file mode 100644
index d273664bdf6a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Range.scala
+++ /dev/null
@@ -1,156 +0,0 @@
-// 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
deleted file mode 100644
index 841e69166feb..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Schema.scala
+++ /dev/null
@@ -1,56 +0,0 @@
-// 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
deleted file mode 100644
index 655ebe75185e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Scope.scala
+++ /dev/null
@@ -1,108 +0,0 @@
-// 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
deleted file mode 100644
index 228e2f02349b..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Signature.scala
+++ /dev/null
@@ -1,706 +0,0 @@
-// 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
deleted file mode 100644
index 93fbb207c4f6..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/SymbolInformation.scala
+++ /dev/null
@@ -1,670 +0,0 @@
-// 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
deleted file mode 100644
index 5d7670dfdd32..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/SymbolOccurrence.scala
+++ /dev/null
@@ -1,178 +0,0 @@
-// 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
deleted file mode 100644
index 3c6fcfbf4c6a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Synthetic.scala
+++ /dev/null
@@ -1,113 +0,0 @@
-// 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
deleted file mode 100644
index f0347e86d9e3..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/TextDocument.scala
+++ /dev/null
@@ -1,271 +0,0 @@
-// 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
deleted file mode 100644
index 41b8e1b3f491..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/TextDocuments.scala
+++ /dev/null
@@ -1,87 +0,0 @@
-// 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
deleted file mode 100644
index ed84d9b2f2d0..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Tree.scala
+++ /dev/null
@@ -1,1088 +0,0 @@
-// 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
deleted file mode 100644
index da24b4847e19..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/generated/Type.scala
+++ /dev/null
@@ -1,2036 +0,0 @@
-// 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
deleted file mode 100644
index 886067ed7a43..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/InvalidProtocolBufferException.scala
+++ /dev/null
@@ -1,55 +0,0 @@
-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
deleted file mode 100644
index 1000fc6601da..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/LiteParser.scala
+++ /dev/null
@@ -1,36 +0,0 @@
-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
deleted file mode 100644
index dc10df6a5bba..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/MD5.scala
+++ /dev/null
@@ -1,30 +0,0 @@
-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
deleted file mode 100644
index 18b8edf8dab0..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbEnum.scala
+++ /dev/null
@@ -1,5 +0,0 @@
-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
deleted file mode 100644
index bad0ff9b8fc8..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbGeneratedMessageCompanion.scala
+++ /dev/null
@@ -1,79 +0,0 @@
-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
deleted file mode 100644
index 8aed9e5b9771..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbInputStream.scala
+++ /dev/null
@@ -1,802 +0,0 @@
-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
deleted file mode 100644
index e20d1691a05d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbMessage.scala
+++ /dev/null
@@ -1,7 +0,0 @@
-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
deleted file mode 100644
index 37da7f868e25..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbOutputStream.scala
+++ /dev/null
@@ -1,610 +0,0 @@
-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
deleted file mode 100644
index 71cb30fbd5fb..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/SemanticdbTypeMapper.scala
+++ /dev/null
@@ -1,18 +0,0 @@
-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
deleted file mode 100644
index 1a193fe99ca6..000000000000
--- a/tests/pos-with-compiler-cc/dotc/semanticdb/internal/WireFormat.scala
+++ /dev/null
@@ -1,20 +0,0 @@
-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
deleted file mode 100644
index 14362260d032..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/AccessProxies.scala
+++ /dev/null
@@ -1,174 +0,0 @@
-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
deleted file mode 100644
index 872c7cc897de..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ArrayApply.scala
+++ /dev/null
@@ -1,76 +0,0 @@
-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
deleted file mode 100644
index e783961649dd..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ArrayConstructors.scala
+++ /dev/null
@@ -1,56 +0,0 @@
-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
deleted file mode 100644
index 0d464d319848..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/BeanProperties.scala
+++ /dev/null
@@ -1,65 +0,0 @@
-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
deleted file mode 100644
index 90c0207ebb6d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/BetaReduce.scala
+++ /dev/null
@@ -1,106 +0,0 @@
-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
deleted file mode 100644
index 21c93cf2dd6d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/Bridges.scala
+++ /dev/null
@@ -1,180 +0,0 @@
-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 DetachedContext) 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
deleted file mode 100644
index f3b3421b8356..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/CapturedVars.scala
+++ /dev/null
@@ -1,173 +0,0 @@
-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 DetachedContext) extends Pure {
-    /** 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
deleted file mode 100644
index 7c8082265161..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/CheckLoopingImplicits.scala
+++ /dev/null
@@ -1,111 +0,0 @@
-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
deleted file mode 100644
index f43d000bbf44..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/CheckNoSuperThis.scala
+++ /dev/null
@@ -1,51 +0,0 @@
-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
deleted file mode 100644
index b63773687f74..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/CheckReentrant.scala
+++ /dev/null
@@ -1,92 +0,0 @@
-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(
-                em"""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
deleted file mode 100644
index 0d5154e212ee..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/CheckStatic.scala
+++ /dev/null
@@ -1,68 +0,0 @@
-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
deleted file mode 100644
index 179625759b10..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/CollectEntryPoints.scala
+++ /dev/null
@@ -1,53 +0,0 @@
-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
deleted file mode 100644
index 7b89c8785e05..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/CollectNullableFields.scala
+++ /dev/null
@@ -1,110 +0,0 @@
-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
deleted file mode 100644
index 80b72075282f..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/CompleteJavaEnums.scala
+++ /dev/null
@@ -1,190 +0,0 @@
-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(em"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
deleted file mode 100644
index 59b90ff7f084..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/Constructors.scala
+++ /dev/null
@@ -1,356 +0,0 @@
-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
deleted file mode 100644
index be58fb41f1da..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ContextFunctionResults.scala
+++ /dev/null
@@ -1,136 +0,0 @@
-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
deleted file mode 100644
index 27f34891fc2c..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/CookComments.scala
+++ /dev/null
@@ -1,34 +0,0 @@
-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
deleted file mode 100644
index 2342170d79b8..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/CountOuterAccesses.scala
+++ /dev/null
@@ -1,59 +0,0 @@
-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/CrossStageSafety.scala b/tests/pos-with-compiler-cc/dotc/transform/CrossStageSafety.scala
deleted file mode 100644
index eba5e0071c01..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/CrossStageSafety.scala
+++ /dev/null
@@ -1,308 +0,0 @@
-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 staging level consistency holds and heals staged types .
- *
- *  Local term references are level 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 level 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 CrossStageSafety(@constructorOnly ictx: DetachedContext) extends TreeMapWithStages(ictx), Checking, Pure {
-  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 level correctness */
-  override protected def transformQuotation(body: Tree, quote: Apply)(using Context): Tree = {
-    val taggedTypes = new CrossStageSafety.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 level 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 =>
-        val tpStr = tp.show
-        val reqTypeStr = reqType.show
-        report.error(
-          ctx.typer.missingArgMsg(tag, reqType, "")
-            .prepend(s"Reference to $tpStr within quotes requires a given $reqTypeStr in scope.\n")
-            .append("\n"),
-            pos)
-        tp
-      case _ =>
-        report.error(em"""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 CrossStageSafety {
-  import tpd._
-
-  class QuoteTypeTags(span: Span)(using DetachedContext) extends Pure {
-
-    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/CtxLazy.scala b/tests/pos-with-compiler-cc/dotc/transform/CtxLazy.scala
deleted file mode 100644
index e3eb74cbfe9c..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/CtxLazy.scala
+++ /dev/null
@@ -1,24 +0,0 @@
-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 initializing 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
deleted file mode 100644
index 192a60c58d9d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/Dependencies.scala
+++ /dev/null
@@ -1,289 +0,0 @@
-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: DetachedContext):
-  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
deleted file mode 100644
index 13adcf5c3f76..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/DropEmptyCompanions.scala.disabled
+++ /dev/null
@@ -1,98 +0,0 @@
-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
deleted file mode 100644
index a363ccaeb0d0..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/DropOuterAccessors.scala
+++ /dev/null
@@ -1,87 +0,0 @@
-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
deleted file mode 100644
index f5add996a94a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ElimByName.scala
+++ /dev/null
@@ -1,161 +0,0 @@
-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),
-        targs = Nil, // !cc! default argument needed
-        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
deleted file mode 100644
index f4310adb6f3d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ElimErasedValueType.scala
+++ /dev/null
@@ -1,143 +0,0 @@
-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 implementation 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) {
-      inDetachedContext:
-        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
deleted file mode 100644
index 2f55826ec2a3..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ElimOpaque.scala
+++ /dev/null
@@ -1,75 +0,0 @@
-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
deleted file mode 100644
index 3ddc8b614bae..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ElimOuterSelect.scala
+++ /dev/null
@@ -1,38 +0,0 @@
-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
deleted file mode 100644
index 83349f1f6199..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ElimPackagePrefixes.scala
+++ /dev/null
@@ -1,37 +0,0 @@
-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
deleted file mode 100644
index 756ddd9bf0eb..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ElimPolyFunction.scala
+++ /dev/null
@@ -1,71 +0,0 @@
-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
deleted file mode 100644
index b0fd3dc50352..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ElimRepeated.scala
+++ /dev/null
@@ -1,299 +0,0 @@
-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(em"""To generate java-compatible varargs:
-                      |  - there must be a single repeated parameter
-                      |  - it must be the last argument in the last parameter list
-                      |""",
-              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(em"$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
deleted file mode 100644
index 02612253c735..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ElimStaticThis.scala
+++ /dev/null
@@ -1,43 +0,0 @@
-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
deleted file mode 100644
index 9a287b2dd1d9..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/EmptyPhase.scala
+++ /dev/null
@@ -1,19 +0,0 @@
-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
deleted file mode 100644
index 2ffef06b4f1e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/Erasure.scala
+++ /dev/null
@@ -1,1071 +0,0 @@
-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) then
-        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}"""
-            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) =>
-            val message = annot.argumentConstant(0) match
-              case Some(c) =>
-                c.stringValue.toMessage
-              case _ =>
-                em"""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."""
-            report.error(message, tree.srcPos)
-          case _ => // OK
-
-      checkNotErasedClass(tree)
-    end checkNotErased
-
-    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.typeOpt)))
-
-    /** 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,
-                    em"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.collectCC {
-        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], DetachedContext) = {
-      // 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
deleted file mode 100644
index cf62cffd4cdb..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/EtaReduce.scala
+++ /dev/null
@@ -1,76 +0,0 @@
-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
deleted file mode 100644
index 41e5b76ca874..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ExpandPrivate.scala
+++ /dev/null
@@ -1,118 +0,0 @@
-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
deleted file mode 100644
index 6bbc1cdfdf37..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ExpandSAMs.scala
+++ /dev/null
@@ -1,194 +0,0 @@
-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 anonymous 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(em"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
deleted file mode 100644
index 2eda974e0ef2..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ExplicitOuter.scala
+++ /dev/null
@@ -1,479 +0,0 @@
-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 constructor
-            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
-    val currentNestingLevel = ctx.nestingLevel
-    atPhaseNoEarlier(explicitOuterPhase.next) { // outer accessors are entered at explicitOuter + 1, should not be defined before.
-      newSymbol(owner, name, SyntheticArtifact | flags, info, coord = cls.coord, nestingLevel = currentNestingLevel)
-    }
-  }
-
-  /** 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.detach)
-
-  /** 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: DetachedContext) 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 accessors 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)
-
-        val c = ctx
-        report.log(i"computing outerpath to $toCls from ${c.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
deleted file mode 100644
index a6f7a29accd7..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ExplicitSelf.scala
+++ /dev/null
@@ -1,64 +0,0 @@
-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
deleted file mode 100644
index 9c580235a2e4..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ExtensionMethods.scala
+++ /dev/null
@@ -1,208 +0,0 @@
-/* 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
deleted file mode 100644
index a7e0795ce195..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/FirstTransform.scala
+++ /dev/null
@@ -1,219 +0,0 @@
-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
deleted file mode 100644
index 25df51d0916d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/Flatten.scala
+++ /dev/null
@@ -1,66 +0,0 @@
-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
deleted file mode 100644
index 8fa0956bed89..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ForwardDepChecks.scala
+++ /dev/null
@@ -1,134 +0,0 @@
-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 DetachedContext)
-  extends OptLevelInfo, 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
deleted file mode 100644
index 74e853f180ba..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/FullParameterization.scala
+++ /dev/null
@@ -1,271 +0,0 @@
-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)(using Context) = tpe match {
-        case tpe: TermRef if rewiredTarget(tpe.symbol, derived).exists => tpe.widen
-        case _ => tpe
-      }
-
-      inDetachedContext:
-        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
deleted file mode 100644
index cc1c0048b68f..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/FunctionXXLForwarders.scala
+++ /dev/null
@@ -1,66 +0,0 @@
-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
deleted file mode 100644
index 9a6ab233e239..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/GenericSignatures.scala
+++ /dev/null
@@ -1,481 +0,0 @@
-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
deleted file mode 100644
index ad06bfb0a504..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/Getters.scala
+++ /dev/null
@@ -1,125 +0,0 @@
-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
deleted file mode 100644
index 3aac7ad46b4d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/HoistSuperArgs.scala
+++ /dev/null
@@ -1,246 +0,0 @@
-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._
-import core.Decorators.*
-
-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)(using Context) = 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)
-            inDetachedContext:
-              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)
-                  }
-                }).detach,
-                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) if !expr.symbol.owner.is(Scala2x) =>
-        // MO: The guard avoids the crash for #16351.
-        // It would be good to dig deeper, but I won't have the time myself to do it.
-        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
deleted file mode 100644
index 6edb60a77245..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/InlinePatterns.scala
+++ /dev/null
@@ -1,65 +0,0 @@
-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
deleted file mode 100644
index 047a187bad68..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/InlineVals.scala
+++ /dev/null
@@ -1,59 +0,0 @@
-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
-            def details = if enclosingInlineds.isEmpty then "" else i"but was: $rhs"
-            report.error(em"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
deleted file mode 100644
index 5ddcf600c63a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/Inlining.scala
+++ /dev/null
@@ -1,83 +0,0 @@
-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
deleted file mode 100644
index c69b342b9a01..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/InstrumentCoverage.scala
+++ /dev/null
@@ -1,528 +0,0 @@
-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
deleted file mode 100644
index 046147f20d82..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/Instrumentation.scala
+++ /dev/null
@@ -1,110 +0,0 @@
-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
deleted file mode 100644
index c95500d856be..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/InterceptedMethods.scala
+++ /dev/null
@@ -1,82 +0,0 @@
-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
deleted file mode 100644
index 68b493a0b9db..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/IsInstanceOfEvaluator.scala.disabled
+++ /dev/null
@@ -1,172 +0,0 @@
-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
deleted file mode 100644
index f85ff75f35c5..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/LambdaLift.scala
+++ /dev/null
@@ -1,343 +0,0 @@
-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 DetachedContext):
-
-    /** 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
-
-    class Deps(tree: Tree, ictx: DetachedContext) extends Dependencies(tree, ictx):
-      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
-
-    val deps = new Deps(ctx.compilationUnit.tpdTree, ctx.withPhase(thisPhase).detach)
-
-    /** 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
deleted file mode 100644
index 3b37ef130231..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/LazyVals.scala
+++ /dev/null
@@ -1,700 +0,0 @@
-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.{ExpandedName, LazyBitMapName, LazyLocalInitName, LazyLocalName}
-import core.StdNames.nme
-import core.Symbols.*
-import core.Types.*
-import core.{Names, StdNames}
-import dotty.tools.dotc.config.Feature
-import transform.MegaPhase.MiniPhase
-import transform.SymUtils.*
-
-import scala.collection.mutable
-
-class LazyVals extends MiniPhase with IdentityDenotTransformer {
-  import LazyVals._
-  import tpd._
-
-  /**
-   * The map contains the list of the offset trees.
-   */
-  class OffsetInfo(var defs: List[Tree], var ord: Int = 0)
-
-  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
-  }
-
-  private def needsBoxing(tp: Type)(using Context): Boolean = tp.classSymbol.isPrimitiveValueClass
-
-  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 and function that computes the field's value. `Evaluating` and
-   * `NullValue` are represented by `object`s and `Waiting` by a class that allows awaiting the completion
-   * of the evaluation. Note that since tail-recursive functions are transformed *before* lazy-vals,
-   * this implementation does involve explicit while loop. `PatternMatcher` is coming before `LazyVals`,
-   * therefore the pattern matching is implemented using if-s.
-   *
-   * ```
-   * private @volatile var _x: AnyRef = null
-   * 
-   * def x: A =
-   *   val result = _x
-   *   if result.isInstanceOf[A] then
-   *     result // possible unboxing applied here
-   *   else if result.eq(NullValue) then
-   *     null // possible unboxing applied here
-   *   else
-   *     x_compute() // possible unboxing applied here
-   * 
-   * private def x_compute(): AnyRef =
-   *   while <EmptyTree> do
-   *     val current: AnyRef = _x
-   *     if current.eq(null) then
-   *       if CAS(_x, null, Evaluating) then
-   *         var resultNullable: AnyRef = null
-   *         var result: AnyRef = null
-   *         try
-   *           resultNullable = rhs
-   *           nullable = null // nulls out the nullable fields used only in initialization
-   *           if resultNullable.eq(null) then
-   *             result = NullValue
-   *           else
-   *             result = resultNullable
-   *         finally
-   *            if !CAS(_x, Evaluating, result) then
-   *              val lock = _x.asInstanceOf[Waiting]
-   *              CAS(_x, lock, result)
-   *              lock.release()
-   *         return resultNullable
-   *     else
-   *       if current.isInstanceOf[LazyValControlState] then
-   *         if current.eq(Evaluating) then // To avoid creating Waiting instance
-   *           CAS(current, current, new Waiting)
-   *         else if current.isInstanceOf[Waiting] then
-   *           current.asInstanceOf[Waiting].await()
-   *         else return null
-   *       else
-   *         return current
-   *   end while
-   *  * ```
-   *
-   * @param memberDef     the transformed lazy field member definition
-   * @param claz          the class containing this lazy val field
-   * @param target        the target synthetic field
-   * @param offset        the offset of the field in the storage allocation of the class
-   * @param thiz          a reference to the transformed class
-   */
-  def mkThreadSafeDef(memberDef: ValOrDefDef,
-                      claz: ClassSymbol,
-                      target: Symbol,
-                      offset: Tree,
-                      thiz: Tree)(using Context): (DefDef, DefDef) = {
-    val tp = memberDef.tpe.widenDealias.resultType.widenDealias
-    val waiting = ref(defn.LazyValsWaitingState)
-    val controlState = ref(defn.LazyValsControlState)
-    val evaluating = Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.evaluating)
-    val nullValue = Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.nullValue)
-    val objCasFlag = Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.objCas)
-    val accessorMethodSymbol = memberDef.symbol.asTerm
-    val lazyInitMethodName = LazyLocalInitName.fresh(memberDef.name.asTermName)
-    val lazyInitMethodSymbol = newSymbol(claz, lazyInitMethodName, Synthetic | Method | Private, MethodType(Nil)(_ => Nil, _ => defn.ObjectType))
-
-    val rhs = memberDef.rhs
-    val rhsMappedOwner = rhs.changeOwnerAfter(memberDef.symbol, lazyInitMethodSymbol, this)
-    val valueSymbol = newSymbol(accessorMethodSymbol, lazyNme.result, Synthetic, defn.ObjectType)
-
-    val immediateValueCondition =
-      if (defn.LazyValsControlState.isSubClass(tp.classSymbol)) then
-        ref(valueSymbol).select(defn.Any_!=).appliedTo(nullLiteral).select(nme.And).appliedTo(ref(valueSymbol)
-          .select(defn.Any_isInstanceOf).appliedToType(defn.LazyValsControlState.typeRef)
-          .select(nme.UNARY_!).appliedToNone)
-      else
-        ref(valueSymbol).select(defn.Any_isInstanceOf).appliedToType(tp)
-
-    val accessorBody =
-      Block(
-        ValDef(valueSymbol, ref(target)) :: Nil,
-        If( // if _x != null && !_x.isInstanceOf[LazyValControlState] then
-          immediateValueCondition,
-            ref(valueSymbol).ensureConforms(tp), // then return _x.asInstanceOf[A]
-            If(
-              ref(valueSymbol).select(defn.Object_eq).appliedTo(nullValue),
-              nullLiteral.ensureConforms(tp),
-              ref(lazyInitMethodSymbol).ensureApplied.ensureConforms(tp) // else return x_compute()
-            )
-        )
-      )
-
-    val accessorDef = DefDef(accessorMethodSymbol, accessorBody)
-
-    // if observed a null (uninitialized) value
-    val initialize = {
-      // var result: AnyRef
-      val resSymbNullable = newSymbol(lazyInitMethodSymbol, lazyNme.resultNullable, Synthetic | Mutable, defn.ObjectType)
-      val resSymb = newSymbol(lazyInitMethodSymbol, lazyNme.result, Synthetic | Mutable, defn.ObjectType)
-      // releasing block in finally
-      val lockRel = {
-        val lockSymb = newSymbol(lazyInitMethodSymbol, lazyNme.lock, Synthetic, waiting.typeOpt)
-        Block(ValDef(lockSymb, ref(target).cast(waiting.typeOpt))
-          :: objCasFlag.appliedTo(thiz, offset, ref(lockSymb), ref(resSymb)) :: Nil,
-          ref(lockSymb).select(lazyNme.RLazyVals.waitingRelease).ensureApplied)
-      }
-      // finally block
-      val fin = If(
-          objCasFlag.appliedTo(thiz, offset, evaluating, ref(resSymb)).select(nme.UNARY_!).appliedToNone,
-          lockRel,
-          unitLiteral
-        )
-      // entire try block
-      val evaluate = Try(
-
-        Block(
-          (Assign(ref(resSymbNullable), if needsBoxing(tp) && rhsMappedOwner != EmptyTree then rhsMappedOwner.ensureConforms(defn.boxedType(tp)) else rhsMappedOwner) // try result = rhs
-          :: If(
-              ref(resSymbNullable).select(defn.Object_eq).appliedTo(nullLiteral),
-              Assign(ref(resSymb), nullValue),
-              Assign(ref(resSymb), ref(resSymbNullable))
-          ) :: Nil)
-          ::: nullOut(nullableFor(accessorMethodSymbol)),
-          unitLiteral),
-        Nil,
-        fin
-      )
-      // if CAS(_, null, Evaluating)
-      If(
-        objCasFlag.appliedTo(thiz, offset, nullLiteral, evaluating),
-        Block(ValDef(resSymb, nullLiteral) :: ValDef(resSymbNullable, nullLiteral) :: evaluate :: Nil, // var result: AnyRef = null
-          Return(ref(resSymbNullable), lazyInitMethodSymbol)),
-        unitLiteral
-      ).withType(defn.UnitType)
-    }
-
-    val current = newSymbol(lazyInitMethodSymbol, lazyNme.current, Synthetic, defn.ObjectType)
-    val ifNotUninitialized =
-      If(
-        ref(current).select(defn.Any_isInstanceOf).appliedToTypeTree(controlState),
-          // if a control state
-          If(
-            ref(current).select(defn.Object_eq).appliedTo(evaluating),
-            // if is Evaluating then CAS(_, Evaluating, new Waiting)
-            Block(
-              objCasFlag.appliedTo(thiz, offset, ref(current), Select(New(waiting), StdNames.nme.CONSTRUCTOR).ensureApplied) :: Nil,
-              unitLiteral
-            ),
-            // if not Evaluating
-            If(
-              ref(current).select(defn.Any_isInstanceOf).appliedToTypeTree(waiting),
-              // if is waiting
-              ref(current).select(defn.Any_asInstanceOf).appliedToTypeTree(waiting).select(lazyNme.RLazyVals.waitingAwaitRelease, _.info.paramInfoss.exists(_.size == 0)).ensureApplied,
-              Return(nullLiteral, lazyInitMethodSymbol)
-            )
-          ),
-        // if not a control state
-        Return(ref(current), lazyInitMethodSymbol)
-      )
-
-    val initBody = Block(ValDef(current, ref(target)) :: Nil, If(ref(current).select(defn.Object_eq).appliedTo(nullLiteral), initialize, ifNotUninitialized).withType(defn.UnitType))
-    val initMainLoop = WhileDo(EmptyTree, initBody) // becomes: while (true) do { body }
-    val initMethodDef = DefDef(lazyInitMethodSymbol, initMainLoop)
-    (accessorDef, initMethodDef)
-  }
-
-  def transformMemberDefThreadSafe(x: ValOrDefDef)(using Context): Thicket = {
-    assert(!(x.symbol is Mutable))
-    if ctx.settings.YlightweightLazyVals.value then
-      transformMemberDefThreadSafeNew(x)
-    else
-      transformMemberDefThreadSafeLegacy(x)
-  }
-
-  def transformMemberDefThreadSafeNew(x: ValOrDefDef)(using Context): Thicket = {
-    import dotty.tools.dotc.core.Types._
-    import dotty.tools.dotc.core.Flags._
-
-    val claz = x.symbol.owner.asClass
-    val thizClass = Literal(Constant(claz.info))
-
-    def offsetName(id: Int) = s"${StdNames.nme.LAZY_FIELD_OFFSET}${if (x.symbol.owner.is(Module)) "_m_" else ""}$id".toTermName
-    val containerName = LazyLocalName.fresh(x.name.asTermName)
-    val containerSymbol = newSymbol(claz, containerName, x.symbol.flags &~ containerFlagsMask | containerFlags | Private, defn.ObjectType, coord = x.symbol.coord).enteredAfter(this)
-    containerSymbol.addAnnotation(Annotation(defn.VolatileAnnot)) // private @volatile var _x: AnyRef
-    containerSymbol.addAnnotations(x.symbol.annotations) // pass annotations from original definition
-    val stat = x.symbol.isStatic
-    if stat then
-      containerSymbol.setFlag(JavaStatic)
-    val getOffset =
-      if stat then
-        Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.getStaticFieldOffset)
-      else
-        Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.getOffsetStatic)
-    val containerTree = ValDef(containerSymbol, nullLiteral)
-
-    // create an offset for this lazy val
-    val offsetSymbol: TermSymbol = appendOffsetDefs.get(claz) match
-      case Some(info) =>
-        newSymbol(claz, offsetName(info.defs.size), Synthetic, defn.LongType).enteredAfter(this)
-      case None =>
-        newSymbol(claz, offsetName(0), Synthetic, defn.LongType).enteredAfter(this)
-    offsetSymbol.nn.addAnnotation(Annotation(defn.ScalaStaticAnnot))
-    val fieldTree = thizClass.select(lazyNme.RLazyVals.getDeclaredField).appliedTo(Literal(Constant(containerName.mangledString)))
-    val offsetTree = ValDef(offsetSymbol.nn, getOffset.appliedTo(fieldTree))
-    val offsetInfo = appendOffsetDefs.getOrElseUpdate(claz, new OffsetInfo(Nil))
-    offsetInfo.defs = offsetTree :: offsetInfo.defs
-    val offset = ref(offsetSymbol.nn)
-
-    val swapOver =
-      if stat then
-        tpd.clsOf(x.symbol.owner.typeRef)
-      else
-        This(claz)
-
-    val (accessorDef, initMethodDef) = mkThreadSafeDef(x, claz, containerSymbol, offset, swapOver)
-    Thicket(containerTree, accessorDef, initMethodDef)
-  }
-
-  /** 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 mkThreadSafeDefLegacy(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 transformMemberDefThreadSafeLegacy(x: ValOrDefDef)(using Context): Thicket = {
-    val tpe = x.tpe.widen.resultType.widen
-    val claz = x.symbol.owner.asClass
-    val thizClass = Literal(Constant(claz.info))
-    val getOffset = Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.getOffset)
-    val getOffsetStatic = Select(ref(defn.LazyValsModule), 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(defn.LazyValsModule), lazyNme.RLazyVals.get)
-    val setFlag = Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.setFlag)
-    val wait =    Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.wait4Notification)
-    val state =   Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.state)
-    val cas =     Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.cas)
-
-    val accessor = mkThreadSafeDefLegacy(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 waitingAwaitRelease: TermName    = "await".toTermName
-      val waitingRelease: TermName         = "countDown".toTermName
-      val evaluating: TermName             = "Evaluating".toTermName
-      val nullValue: TermName              = "NullValue".toTermName
-      val objCas: TermName                 = "objCAS".toTermName
-      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 getStaticFieldOffset: TermName   = "getStaticFieldOffset".toTermName
-      val getDeclaredField: TermName       = "getDeclaredField".toTermName
-    }
-    val flag: TermName        = "flag".toTermName
-    val state: TermName       = "state".toTermName
-    val result: TermName      = "result".toTermName
-    val resultNullable: TermName      = "resultNullable".toTermName
-    val value: TermName       = "value".toTermName
-    val initialized: TermName = "initialized".toTermName
-    val initialize: TermName  = "initialize".toTermName
-    val retry: TermName       = "retry".toTermName
-    val current: TermName     = "current".toTermName
-    val lock: TermName        = "lock".toTermName
-    val discard: TermName     = "discard".toTermName
-  }
-}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/LetOverApply.scala b/tests/pos-with-compiler-cc/dotc/transform/LetOverApply.scala
deleted file mode 100644
index e7ff6d10c222..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/LetOverApply.scala
+++ /dev/null
@@ -1,37 +0,0 @@
-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
deleted file mode 100644
index 6acb1013d509..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/LiftTry.scala
+++ /dev/null
@@ -1,88 +0,0 @@
-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
deleted file mode 100644
index 626cb9687df4..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/Literalize.scala.disabled
+++ /dev/null
@@ -1,95 +0,0 @@
-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
deleted file mode 100644
index 14ccdc5c6f86..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/MacroTransform.scala
+++ /dev/null
@@ -1,60 +0,0 @@
-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, 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
deleted file mode 100644
index 14dd7f17d58a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/MegaPhase.scala
+++ /dev/null
@@ -1,1066 +0,0 @@
-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, 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
deleted file mode 100644
index 3552d08e81f2..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/Memoize.scala
+++ /dev/null
@@ -1,222 +0,0 @@
-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
deleted file mode 100644
index 9a220d9c4f8c..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/Mixin.scala
+++ /dev/null
@@ -1,329 +0,0 @@
-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
deleted file mode 100644
index fa1c09806893..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/MixinOps.scala
+++ /dev/null
@@ -1,104 +0,0 @@
-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
deleted file mode 100644
index c50a96dc8b81..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/MoveStatics.scala
+++ /dev/null
@@ -1,93 +0,0 @@
-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
deleted file mode 100644
index ddf858994220..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/NonLocalReturns.scala
+++ /dev/null
@@ -1,106 +0,0 @@
-package dotty.tools.dotc
-package transform
-
-import core._
-import Contexts._, Symbols._, Types._, Flags._, StdNames._
-import MegaPhase._
-import NameKinds.NonLocalReturnKeyName
-import config.SourceVersion.*
-import Decorators.em
-
-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(
-          em"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
deleted file mode 100644
index 9e02b291b14e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/OverridingPairs.scala
+++ /dev/null
@@ -1,227 +0,0 @@
-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 DetachedContext) extends Pure:
-
-    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/ParamForwarding.scala b/tests/pos-with-compiler-cc/dotc/transform/ParamForwarding.scala
deleted file mode 100644
index 8c93ffb90232..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ParamForwarding.scala
+++ /dev/null
@@ -1,87 +0,0 @@
-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
deleted file mode 100644
index b1b268634736..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/PatternMatcher.scala
+++ /dev/null
@@ -1,1055 +0,0 @@
-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 DetachedContext) {
-
-    // ------- 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 extends Pure { 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
deleted file mode 100644
index b27bbdc0fccd..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/PickleQuotes.scala
+++ /dev/null
@@ -1,383 +0,0 @@
-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, tpt = 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
deleted file mode 100644
index 63b3e15f2728..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/Pickler.scala
+++ /dev/null
@@ -1,154 +0,0 @@
-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, Message}
-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[Message]()
-      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()(using Context): 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 += inDetachedContext(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(em"""pickling difference for $cls in ${cls.source}, for details:
-                    |
-                    |  diff before-pickling.txt after-pickling.txt""")
-  end testSame
-}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/PostInlining.scala b/tests/pos-with-compiler-cc/dotc/transform/PostInlining.scala
deleted file mode 100644
index 0cfd3650ad0b..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/PostInlining.scala
+++ /dev/null
@@ -1,35 +0,0 @@
-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
deleted file mode 100644
index a669be3d1e3c..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/PostTyper.scala
+++ /dev/null
@@ -1,500 +0,0 @@
-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, em"${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.asInstanceOf[MethodType]
-          val app =
-            if (methType.isErasedMethod)
-              tpd.cpy.Apply(tree)(
-                tree.fun,
-                tree.args.mapConserve(arg =>
-                  if methType.isResultDependent then
-                    Checking.checkRealizable(arg.tpe, arg.srcPos, "erased argument")
-                  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
-          CrossVersionChecks.checkExperimentalRef(call.symbol, pos)
-          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
deleted file mode 100644
index db9e28d7aad7..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/PreRecheck.scala
+++ /dev/null
@@ -1,19 +0,0 @@
-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
deleted file mode 100644
index 6d8f7bdb32cb..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ProtectedAccessors.scala
+++ /dev/null
@@ -1,97 +0,0 @@
-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(em"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
deleted file mode 100644
index 568512207fde..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/PruneErasedDefs.scala
+++ /dev/null
@@ -1,72 +0,0 @@
-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
deleted file mode 100644
index b747d7d6b9e4..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/PureStats.scala
+++ /dev/null
@@ -1,35 +0,0 @@
-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
deleted file mode 100644
index e566a6d7482a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/Recheck.scala
+++ /dev/null
@@ -1,576 +0,0 @@
-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 recheckSelectQualifier(tree: Select)(using Conext): Type =
-      val Select(qual, name) = tree
-      val proto =
-        if tree.symbol == defn.Any_asInstanceOf then WildcardType
-        else AnySelectionProto
-      recheck(qual, proto).widenIfUnstable
-
-    def recheckSelect(tree: Select, pt: Type)(using Context): Type =
-      recheckSelection(tree, recheckSelectQualifier(tree), name, pt)
-
-    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])
-
-    /** 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 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 recheckApplication(tree: Tree, qualType: Type, argTypes: List[Type])(using Context): Type =
-      constFold(tree, instantiate(fntpe, argTypes, tree.fun.symbol))
-
-    def recheckApply(tree: Apply, pt: Type)(using Context): Type =
-      fun
-      val funTp = recheck(tree.fun)
-      // reuse the tree's type on signature polymorphic methods, instead of using the (wrong) rechecked one
-      val funtpe = if tree.fun.symbol.originalSignaturePolymorphic.exists then tree.fun.tpe else funTp
-      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
deleted file mode 100644
index 0882247df8a6..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ReifiedReflect.scala
+++ /dev/null
@@ -1,109 +0,0 @@
-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.Assign(<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
deleted file mode 100644
index 1cf687187eeb..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/RepeatableAnnotations.scala
+++ /dev/null
@@ -1,66 +0,0 @@
-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 Flags._
-
-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.is(JavaDefined) =>
-        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
deleted file mode 100644
index dd109ce153eb..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ResolveSuper.scala
+++ /dev/null
@@ -1,128 +0,0 @@
-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
deleted file mode 100644
index d01be0419a4d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/RestoreScopes.scala
+++ /dev/null
@@ -1,56 +0,0 @@
-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
deleted file mode 100644
index bffa743fdb88..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/SelectStatic.scala
+++ /dev/null
@@ -1,101 +0,0 @@
-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 transformation 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
deleted file mode 100644
index 2f586104c4e3..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/SeqLiterals.scala
+++ /dev/null
@@ -1,44 +0,0 @@
-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
deleted file mode 100644
index d17dbbecc555..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/SetRootTree.scala
+++ /dev/null
@@ -1,49 +0,0 @@
-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
deleted file mode 100644
index 6ffa05075201..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/SpecializeApplyMethods.scala
+++ /dev/null
@@ -1,124 +0,0 @@
-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
deleted file mode 100644
index c1f891d6293a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/SpecializeFunctions.scala
+++ /dev/null
@@ -1,114 +0,0 @@
-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
deleted file mode 100644
index 5237ecbcef8a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/SpecializeTuples.scala
+++ /dev/null
@@ -1,53 +0,0 @@
-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
deleted file mode 100644
index 09c820169179..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/Splicer.scala
+++ /dev/null
@@ -1,254 +0,0 @@
-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 dotty.tools.dotc.quoted.Interpreter
-
-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.*
-  import Interpreter.*
-
-  /** 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 SpliceInterpreter(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 =
-            em"""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    ")}
-              """
-          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.
-   *  Interpreter is assumed to start at quotation level -1.
-   */
-  private class SpliceInterpreter(pos: SrcPos, classLoader: ClassLoader)(using Context) extends Interpreter(pos, classLoader) {
-
-    override protected  def interpretTree(tree: Tree)(implicit env: Env): Object = tree match {
-      // Interpret level -1 quoted code `'{...}` (assumed without level 0 splices)
-      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
-        }
-        new ExprImpl(Inlined(EmptyTree, Nil, QuoteUtils.changeOwnerOfTree(quoted1, ctx.owner)).withSpan(quoted1.span), SpliceScope.getCurrent)
-
-      // Interpret level -1 `Type.of[T]`
-      case Apply(TypeApply(fn, quoted :: Nil), _) if fn.symbol == defn.QuotedTypeModule_of =>
-        new TypeImpl(QuoteUtils.changeOwnerOfTree(quoted, ctx.owner), SpliceScope.getCurrent)
-
-      case _ =>
-        super.interpretTree(tree)
-    }
-  }
-}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Splicing.scala b/tests/pos-with-compiler-cc/dotc/transform/Splicing.scala
deleted file mode 100644
index 3a3aa7e89445..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/Splicing.scala
+++ /dev/null
@@ -1,392 +0,0 @@
-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: CrossStageSafety.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 CrossStageSafety.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
deleted file mode 100644
index c2c6f76cd0fc..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/Staging.scala
+++ /dev/null
@@ -1,83 +0,0 @@
-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 staging level consistency holds and heals staged 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 staging levels hold 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 stagingCtx = freshStagingContext
-          val checker = new CrossStageSafety(stagingCtx) {
-            // !cc! type error is checker is defined as val checker = new CrossStageSafety { ... }
-            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 CrossStageSafety(ctx.detach).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
deleted file mode 100644
index 2307f759b571..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/SuperAccessors.scala
+++ /dev/null
@@ -1,224 +0,0 @@
-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(
-            em"Internal error: unable to store accessor definition in ${clazz}. clazz.hasPackageFlag=${clazz.is(Package)}. Accessor required for ${sel.toString} ($sel)",
-            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(em"super may be not be used on ${sym.underlyingSymbol}", sel.srcPos)
-    else if (isDisallowed(sym))
-      report.error(em"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(
-            em"${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(
-                em"${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
deleted file mode 100644
index 0a6fa9217303..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/SymUtils.scala
+++ /dev/null
@@ -1,432 +0,0 @@
-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)
-
-    /** 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
deleted file mode 100644
index 0a9a7a83948c..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/SyntheticMembers.scala
+++ /dev/null
@@ -1,651 +0,0 @@
-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
deleted file mode 100644
index 718d0ffdfa3e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/TailRec.scala
+++ /dev/null
@@ -1,461 +0,0 @@
-package dotty.tools.dotc
-package transform
-
-import ast.{TreeTypeMap, tpd}
-import config.Printers.tailrec
-import core.*
-import Contexts.*, Flags.*, Symbols.*, Decorators.em
-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 = inDetachedContext:
-              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 => inDetachedContext:
-            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(em"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
deleted file mode 100644
index ffed65f7676e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/TransformWildcards.scala
+++ /dev/null
@@ -1,34 +0,0 @@
-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
deleted file mode 100644
index b0d7fb89985f..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/TreeChecker.scala
+++ /dev/null
@@ -1,726 +0,0 @@
-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(em"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(em"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.typeOpt), 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),
-               i"""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 CrossStageSafety 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)
-      val c = ctx // !cc! needed as a stable anchor for outersIterator below
-      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 = ${c.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], DetachedContext) = {
-      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: Context ?-> 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
deleted file mode 100644
index aec44d5987bf..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/TreeExtractors.scala
+++ /dev/null
@@ -1,52 +0,0 @@
-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
deleted file mode 100644
index 9dd1000af954..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/TreeMapWithStages.scala
+++ /dev/null
@@ -1,164 +0,0 @@
-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 { this: TreeMapWithStages^{} =>
-
-  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): DetachedContext =
-    ctx.fresh.setProperty(LevelOfKey, new mutable.HashMap[Symbol, Int]).detach
-
-}
diff --git a/tests/pos-with-compiler-cc/dotc/transform/TryCatchPatterns.scala b/tests/pos-with-compiler-cc/dotc/transform/TryCatchPatterns.scala
deleted file mode 100644
index f9779cbbfee4..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/TryCatchPatterns.scala
+++ /dev/null
@@ -1,104 +0,0 @@
-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
deleted file mode 100644
index 6fba0bca4ce3..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/TupleOptimizations.scala
+++ /dev/null
@@ -1,221 +0,0 @@
-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(em"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(em"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
deleted file mode 100644
index 591eb1604216..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/TypeTestsCasts.scala
+++ /dev/null
@@ -1,394 +0,0 @@
-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: Message)(using Context): Boolean =
-            if flagUnrelated then
-              if inMatch then
-                report.error(why.prepend("this case is unreachable since "), expr.srcPos)
-              else
-                report.warning(why.prepend("this will always yield false since "), 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(em"$exprType is not a subclass of $testCls")
-                else if (unrelated)
-                  unreachable(em"$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(em"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(em"$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(em"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
deleted file mode 100644
index a897503ef275..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/TypeUtils.scala
+++ /dev/null
@@ -1,120 +0,0 @@
-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.intersect(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
deleted file mode 100644
index 95d40102c5a7..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/UncacheGivenAliases.scala
+++ /dev/null
@@ -1,65 +0,0 @@
-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
deleted file mode 100644
index a7ccaa19d90a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/UninitializedDefs.scala
+++ /dev/null
@@ -1,48 +0,0 @@
-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
deleted file mode 100644
index 879a885d626e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/VCElideAllocations.scala
+++ /dev/null
@@ -1,55 +0,0 @@
-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
deleted file mode 100644
index 219945d4ebb1..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/VCInlineMethods.scala
+++ /dev/null
@@ -1,113 +0,0 @@
-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
deleted file mode 100644
index a86bf2c48fb5..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/ValueClasses.scala
+++ /dev/null
@@ -1,57 +0,0 @@
-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
deleted file mode 100644
index ba42d826fe82..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/YCheckPositions.scala
+++ /dev/null
@@ -1,72 +0,0 @@
-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
deleted file mode 100644
index 1efb3c88149e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/init/Checker.scala
+++ /dev/null
@@ -1,72 +0,0 @@
-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
deleted file mode 100644
index 874560603bed..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/init/Errors.scala
+++ /dev/null
@@ -1,145 +0,0 @@
-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(em"$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
deleted file mode 100644
index 6ddc0e18d995..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/init/Semantic.scala
+++ /dev/null
@@ -1,1806 +0,0 @@
-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
-
-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] = (DetachedContext, 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: List[Error] = 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())
-        // !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
deleted file mode 100644
index ff8d89920791..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/localopt/FormatChecker.scala
+++ /dev/null
@@ -1,286 +0,0 @@
-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
deleted file mode 100644
index 79d94c26c692..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/localopt/FormatInterpolatorTransform.scala
+++ /dev/null
@@ -1,39 +0,0 @@
-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
deleted file mode 100644
index 5cad7ba72831..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/localopt/StringInterpolatorOpt.scala
+++ /dev/null
@@ -1,170 +0,0 @@
-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
deleted file mode 100644
index 7fdd4316acf2..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/patmat/Space.scala
+++ /dev/null
@@ -1,966 +0,0 @@
-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))
-    }
-    || unappResult.derivesFrom(defn.NonEmptyTupleClass)
-  }
-
-  /** 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, DetachedContext), Boolean]
-
-  override def isSubspace(a: Space, b: Space)(using Context): Boolean =
-    isSubspaceCache.getOrElseUpdate((a, b, ctx.detach), 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))
-      val dedupedStr = show(deduped)
-      report.warning(PatternMatchExhaustivity(dedupedStr, 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
deleted file mode 100644
index 6471e58d4ddc..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/sjs/AddLocalJSFakeNews.scala
+++ /dev/null
@@ -1,98 +0,0 @@
-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(em"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
deleted file mode 100644
index 259ada490a8f..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/sjs/ExplicitJSClasses.scala
+++ /dev/null
@@ -1,730 +0,0 @@
-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(em"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(em"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
deleted file mode 100644
index 9abf9a919d6d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/sjs/JSExportUtils.scala
+++ /dev/null
@@ -1,38 +0,0 @@
-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
deleted file mode 100644
index 30eed76b18ec..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/sjs/JSSymUtils.scala
+++ /dev/null
@@ -1,255 +0,0 @@
-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
deleted file mode 100644
index f2fa93848d49..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/sjs/JUnitBootstrappers.scala
+++ /dev/null
@@ -1,332 +0,0 @@
-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 Decorators.{em, collectCC}
-
-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.collectCC {
-      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(em"$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
deleted file mode 100644
index 25ab46712e70..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/sjs/PrepJSExports.scala
+++ /dev/null
@@ -1,467 +0,0 @@
-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(
-                em"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
deleted file mode 100644
index d934dc179989..000000000000
--- a/tests/pos-with-compiler-cc/dotc/transform/sjs/PrepJSInterop.scala
+++ /dev/null
@@ -1,1329 +0,0 @@
-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(
-                  em"Using an anonymous function as a SAM for the JavaScript type ${
-                     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(em"js.Dynamic.literal does not have a method named $s", tree)
-            case _ =>
-              report.error(em"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(em"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(
-                em"${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(
-              em"""error overriding ${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(em"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(em"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(em"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(em"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 rhs: Ident if rhs.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(em"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(
-            em"@${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
deleted file mode 100644
index 6ffbf0465120..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/Applications.scala
+++ /dev/null
@@ -1,2409 +0,0 @@
-package dotty.tools
-package dotc
-package typer
-
-import core._
-import ast.{Trees, tpd, untpd, desugar}
-import util.Stats.record
-import util.{SrcPos, NoSourcePosition}
-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._, NullOpsDecorator.*
-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(em"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)
-
-  def retypeSignaturePolymorphicFn(fun: Tree, methType: Type)(using Context): Tree =
-    val sym1 = fun.symbol
-    val flags2 = sym1.flags | NonMember // ensures Select typing doesn't let TermRef#withPrefix revert the type
-    val sym2 = sym1.copy(info = methType, flags = flags2) // symbol not entered, to avoid overload resolution problems
-    fun.withType(sym2.termRef)
-}
-
-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(em"$methString does not take parameters")
-    }
-
-    /** 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)
-                    em"parameter $aname of $methString is already instantiated"
-                  else
-                    em"$methString does not have a parameter $aname"
-                fail(msg, 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.is(JavaAnnotation)
-
-    /** 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", 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 =>
-                  em"can't supply unit value with infix notation because nullary $methString takes no arguments; use dotted invocation instead: (...).${methRef.name}()"
-                case _ =>
-                  em"too many arguments for $methString"
-              fail(msg, 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).detach)
-      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 if funRef.symbol.isSignaturePolymorphic =>
-            // synthesize a method type based on the types at the call site.
-            // one can imagine the original signature-polymorphic method as
-            // being infinitely overloaded, with each individual overload only
-            // being brought into existence as needed
-            val originalResultType = funRef.symbol.info.resultType.stripNull
-            val resultType =
-              if !originalResultType.isRef(defn.ObjectClass) then originalResultType
-              else AvoidWildcardsMap()(proto.resultType.deepenProtoTrans) match
-                case SelectionProto(nme.asInstanceOf_, PolyProto(_, resTp), _, _) => resTp
-                case resTp if isFullyDefined(resTp, ForceDegree.all) => resTp
-                case _ => defn.ObjectType
-            val methType = MethodType(proto.typedArgs().map(_.tpe.widen), resultType)
-            val fun2 = Applications.retypeSignaturePolymorphicFn(fun1, methType)
-            simpleApply(fun2, proto)
-          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(em"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(
-          em"""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, em"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, em"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 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)(using Context): 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(em"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, wildcardOnly: Boolean = false)(using Context): Type = tp match {
-    case mt: MethodType if mt.isImplicitMethod =>
-      stripImplicit(resultTypeApprox(mt, wildcardOnly))
-    case pt: PolyType =>
-      pt.derivedLambdaType(pt.paramNames, pt.paramInfos,
-          stripImplicit(pt.resultType, wildcardOnly = true))
-            // can't use TypeParamRefs for parameter references in `resultTypeApprox`
-            // since their bounds can refer to type parameters in `pt` that are not
-            // bound by the constraint. This can lead to hygiene violations if subsequently
-            // `pt` itself is added to the constraint. Test case is run/enrich-gentraversable.scala.
-        .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
deleted file mode 100644
index ec7bd6f8abc9..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/Checking.scala
+++ /dev/null
@@ -1,1561 +0,0 @@
-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
-      inDetachedContext:
-        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, em"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 DetachedContext) 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(
-            em"$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 protected
-   *                  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(em"$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: Message) =
-      if (sym.isAllOf(flag1 | flag2)) fail(msg)
-    def checkCombination(flag1: FlagSet, flag2: FlagSet) =
-      if sym.isAllOf(flag1 | flag2) then
-        fail(em"illegal combination of modifiers: `${flag1.flagsString}` and `${flag2.flagsString}` for: $sym")
-    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.isExtensibleClass then fail(em"`transparent` can only be used for extensible classes and traits")
-      else
-        if !sym.isInlineMethod then fail(em"`transparent` can only be used for inline methods")
-    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}")
-    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(em"Inline methods cannot be @tailrec")
-    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(em"Traits cannot have secondary constructors$addendum")
-    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, em"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[Message] = 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(report.errorOrMigrationWarning(_, 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
-      if p2.is(Inline) then
-        report.error("Cannot override inline parameter with a non-inline parameter", p1.srcPos)
-      else
-        report.error("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) =>
-          inDetachedContext:
-            def check(stable: -> String) =
-              Feature.checkExperimentalFeature("features", imp.srcPos,
-                i"\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(em"$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"
-          em"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
-      inDetachedContext:
-        def rewriteMsg = Message.rewriteNotice("This patch", `3.2-migration`)
-        report.gradualErrorOrMigrationWarning(
-            message.append(
-              i"""|
-                  |
-                  |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
-      inDetachedContext:
-        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 the expected type is
-   *  a convertible formal parameter type or that implicit conversions are enabled.
-   */
-  def checkImplicitConversionUseOK(tree: Tree, expected: Type)(using Context): Unit =
-    val sym = tree.symbol
-    if sym.name == nme.apply
-       && sym.owner.derivesFrom(defn.ConversionClass)
-       && !sym.info.isErroneous
-       && !expected.isConvertibleParam
-    then
-      inDetachedContext:
-        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(
-              em"""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: Context ?-> String = "")(using Context): Type = {
-    def checkGoodBounds(tp: Type) = tp match {
-      case tp @ TypeBounds(lo, hi) if !(lo <:< hi) =>
-        report.error(em"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(em"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 (called.is(JavaAnnotation))
-        report.error(em"${called.name} must appear without any argument to be a valid class parent because it is a Java annotation", call.srcPos)
-      if (caller.is(Trait))
-        report.error(em"$caller may not call constructor of $called", call.srcPos)
-      else if (called.is(Trait) && !caller.mixins.contains(called))
-        report.error(em"""$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(em"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(em"""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(em"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(em"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 that the class corresponding to this tree is either a Scala or Java annotation.
-   *
-   *  @return The original tree or an error tree in case `tree` isn't a valid
-   *          annotation or already an error tree.
-   */
-  def checkAnnotClass(tree: Tree)(using Context): Tree =
-    if tree.tpe.isError then
-      return tree
-    val cls = Annotations.annotClass(tree)
-    if cls.is(JavaDefined) then
-      if !cls.is(JavaAnnotation) then
-        errorTree(tree, em"$cls is not a valid Java annotation: it was not declared with `@interface`")
-      else tree
-    else if !cls.derivesFrom(defn.AnnotationClass) then
-      errorTree(tree, em"$cls is not a valid Scala annotation: it does not extend `scala.annotation.Annotation`")
-    else tree
-
-  /** 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(em"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, expected: Type)(using Context): Unit = ()
-  override def checkFeasibleParent(tp: Type, pos: SrcPos, where: Context ?-> 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
deleted file mode 100644
index 81b1de67b707..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/ConstFold.scala
+++ /dev/null
@@ -1,210 +0,0 @@
-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
deleted file mode 100644
index ef9599be551c..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/CrossVersionChecks.scala
+++ /dev/null
@@ -1,185 +0,0 @@
-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(em"${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(
-          em"""$symbol overrides concrete, non-deprecated definition(s):
-              |    ${concrOvers.map(_.name).mkString(", ")}""",
-          tree.srcPos)
-    }
-  }
-
-  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 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
deleted file mode 100644
index 8fdc468780ba..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/Deriving.scala
+++ /dev/null
@@ -1,312 +0,0 @@
-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(em"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(em"${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(em"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
deleted file mode 100644
index d819528ff556..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/Docstrings.scala
+++ /dev/null
@@ -1,67 +0,0 @@
-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(em"`@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
deleted file mode 100644
index b69d83b2dcd5..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/Dynamic.scala
+++ /dev/null
@@ -1,249 +0,0 @@
-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, em"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
deleted file mode 100644
index 400acafaea93..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/ErrorReporting.scala
+++ /dev/null
@@ -1,276 +0,0 @@
-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 reporting._
-import collection.mutable
-import language.experimental.pureFunctions
-import annotation.retains
-
-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: 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(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 =>
-        i"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 => i" and expected result type $tp"
-          }
-          i"(${tp.typedArgs().tpes}%, %)$result"
-        s"arguments ${argStr(tp)}"
-      case _ =>
-        i"expected type $tp"
-    }
-
-    def anonymousTypeMemberStr(tpe: Type): String = {
-      val kind = tpe match {
-        case _: TypeBounds => "type with bounds"
-        case _: MethodOrPoly => "method"
-        case _ => "value of type"
-      }
-      i"$kind $tpe"
-    }
-
-    def overloadedAltsStr(alts: List[SingleDenotation]): String =
-      i"""overloaded alternatives of ${denotStr(alts.head)} with types
-         | ${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)
-    }
-
-    /** Explain info of symbol `sym` as a member of class `base`.
-     *   @param  showLocation  if true also show sym's location.
-     */
-    def infoString(sym: Symbol, base: Type, showLocation: Boolean): String =
-      val sym1 = sym.underlyingSymbol
-      def info = base.memberInfo(sym1)
-      val infoStr =
-        if sym1.isAliasType then i", which equals ${info.bounds.hi}"
-        else if sym1.isAbstractOrParamType && info != TypeBounds.empty then i" with bounds$info"
-        else if sym1.is(Module) then ""
-        else if sym1.isTerm then i" of type $info"
-        else ""
-      i"${if showLocation then sym1.showLocated else sym1}$infoStr"
-
-    def infoStringWithLocation(sym: Symbol, base: Type) =
-      infoString(sym, base, showLocation = true)
-
-    def exprStr(tree: Tree): String = refStr(tree.tpe)
-
-    def takesNoParamsMsg(tree: Tree, kind: String): Message =
-      if (tree.tpe.widen.exists)
-        em"${exprStr(tree)} does not take ${kind}parameters"
-      else {
-        em"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.
-
-      inDetachedContext:
-        val 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 dependentMsg: Message =
-    """Term-dependent types are experimental,
-      |they must be enabled with a `experimental.dependent` language import or setting""".stripMargin.toMessage
-
-  def err(using ctx: Context): Errors @retains(ctx) = new Errors
-}
diff --git a/tests/pos-with-compiler-cc/dotc/typer/EtaExpansion.scala b/tests/pos-with-compiler-cc/dotc/typer/EtaExpansion.scala
deleted file mode 100644
index 46725f0fa6b2..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/EtaExpansion.scala
+++ /dev/null
@@ -1,293 +0,0 @@
-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
deleted file mode 100644
index 1f7286b02b5a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/Implicits.scala
+++ /dev/null
@@ -1,1915 +0,0 @@
-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, retains}
-
-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: DetachedContext) extends Pure {
-    val irefCtx: DetachedContext =
-      if (initctx eq NoContext) initctx else initctx.retractMode(Mode.ImplicitsEnabled).detach
-    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: DetachedContext) 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: DetachedContext) 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) =>
-          val explanation = tpe.explanation
-          untpd.SearchFailureIdent(nme.AMBIGUOUS, s"/* ambiguous: $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 =>
-        i"provide an extension method `$name` on ${argument.tpe}"
-      case NoType =>
-        if (argument.isEmpty) i"match expected type"
-        else i"convert from ${argument.tpe} to expected type"
-      case _ =>
-        if (argument.isEmpty) i"match type ${clarify(expectedType)}"
-        else i"convert from ${argument.tpe} to ${clarify(expectedType)}"
-    }
-
-    /** 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 msg(using Context): Message =
-      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 msg(using Context) =
-      super.msg.append("\nThe 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 msg(using Context): Message =
-      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".withoutDisambiguation()
-    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 msg(using Context): Message =
-      em"${err.refStr(ref)} does not $qualify"
-  }
-
-  class DivergingImplicit(ref: TermRef,
-                          val expectedType: Type,
-                          val argument: Tree) extends SearchFailureType {
-    def msg(using Context): Message =
-      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 msg(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
-
-  /** 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 msg(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(
-              em"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): Message = {
-    inDetachedContext:
-      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
-      MissingImplicitArgument(arg, pt, where, paramSymWithMethodCallTree, ignoredInstanceNormalImport)
-  }
-
-  /** 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")
-        i"parameter of ${qual.tpe.widen}$addendum"
-      case _ =>
-        i"${ 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.
-
-        val searchCtx =
-          if ctx.owner.isImport then
-            def nextDifferent(searchCtx: Context): Context =
-              if (searchCtx.scope eq ctx.scope) && (searchCtx.owner eq ctx.owner.owner)
-              then nextDifferent(searchCtx.outer)
-              else searchCtx
-            nextDifferent(ctx.outer)
-          else ctx
-
-        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(
-                    result.reason.msg
-                      .prepend(s"According to new implicit resolution rules, this will be ambiguous:\n"),
-                    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
-          def warnIn(c: Context): Unit =
-            if c.outer.typer eq ctx.typer then warnIn(c.outer)
-            else report.warning(ImplicitSearchTooLargeWarning(limit, h.openSearchPairs), srcPos)(using c)
-          warnIn(ctx)
-        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(
-          em"""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)(using Context): 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)(using Context): 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] = inDetachedContext:
-              (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 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 DetachedContext) 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 = inDetachedContext {
-              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 = inDetachedContext {
-              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 DetachedContext) extends Pure:
-  private val elemsMap = new util.HashMap[TermSymbol, Type | List[Type]]
-  private val elemsBuf = new mutable.ListBuffer[TermSymbol]
-
-  def isEmpty = elemsBuf.isEmpty
-
-  def += (ref: TermRef): Unit =
-    if ref.symbol.exists then
-      val pre = ref.prefix
-      val sym = ref.symbol.asTerm
-      elemsMap.lookup(sym) match
-        case null =>
-          elemsMap(sym) = pre
-          elemsBuf += sym
-        case prefix: Type =>
-          if !(prefix =:= pre) then elemsMap(sym) = pre :: prefix :: Nil
-        case prefixes: List[Type] =>
-          if !prefixes.exists(_ =:= pre) then elemsMap(sym) = pre :: prefixes
-
-  def ++= (that: TermRefSet): Unit =
-    if !that.isEmpty then that.foreach(+=)
-
-  def foreach[U](f: TermRef => U): Unit =
-    for sym <- elemsBuf do
-      elemsMap(sym) match
-        case prefix: Type => f(TermRef(prefix, sym))
-        case prefixes: List[Type] =>
-          for prefix <- prefixes do f(TermRef(prefix, sym))
-
-  // 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
deleted file mode 100644
index 8f4ab5de30cb..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/ImportInfo.scala
+++ /dev/null
@@ -1,231 +0,0 @@
-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): DetachedContext =
-      rootRefs.foldLeft(c)((ctx, ref) => ctx.fresh.setImportInfo(rootImport(ref))).detach
-
-    def withRootImports: DetachedContext =
-      given DetachedContext = c.detach
-      c.withRootImports(defn.rootImportFns).detach
-}
-
-/** 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, 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 =>
-            def recur(c: Context): Boolean =
-              if c.importInfo eqn ctx.importInfo then recur(c.outer)
-              else
-                val cinfo = c.importInfo
-                (cinfo != null) && cinfo.featureImported(feature)(using c)
-            recur(ctx.outer)
-      )
-    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
deleted file mode 100644
index c12da7eb0fd4..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/ImportSuggestions.scala
+++ /dev/null
@@ -1,358 +0,0 @@
-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 = inDetachedContext:
-          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
deleted file mode 100644
index 94a4d6f3e71c..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/Inferencing.scala
+++ /dev/null
@@ -1,780 +0,0 @@
-package dotty.tools
-package dotc
-package typer
-
-import core._
-import ast._
-import Contexts._, Types._, Flags._, Symbols._
-import ProtoTypes._
-import NameKinds.UniqueName
-import util.Spans._
-import util.{Stats, SimpleIdentityMap, SimpleIdentitySet, 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 occurrences with upper GADT bound
-      *   - replacing contravariant occurrences with lower GADT bound
-      *   - leaving invariant occurrences 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
-      *     occurrences 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.collectCC {
-          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 occurrences 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 then
-      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
-
-        /** Values of this type report type variables to instantiate with variance indication:
-         *    +1  variable appears covariantly, can be instantiated from lower bound
-         *    -1  variable appears contravariantly, can be instantiated from upper bound
-         *     0  variable does not appear at all, can be instantiated from either bound
-         */
-        type ToInstantiate = List[(TypeVar, Int)]
-
-        val toInstantiate: ToInstantiate =
-          val buf = new mutable.ListBuffer[(TypeVar, Int)]
-          for tvar <- qualifying do
-            if !tvar.isInstantiated && constraint.contains(tvar) && tvar.nestingLevel >= ctx.nestingLevel then
-              constrainIfDependentParamRef(tvar, tree)
-              if !tvar.isInstantiated then
-                // isInstantiated needs to be checked again, since previous interpolations could already have
-                // instantiated `tvar` through unification.
-                val v = vs(tvar)
-                if v == null then buf += ((tvar, 0))
-                else if v.intValue != 0 then buf += ((tvar, v.intValue))
-                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")
-                )
-          buf.toList
-
-        def typeVarsIn(xs: ToInstantiate): TypeVars =
-          xs.foldLeft(SimpleIdentitySet.empty: TypeVars)((tvs, tvi) => tvs + tvi._1)
-
-        /** Filter list of proposed instantiations so that they don't constrain further
-         *  the current constraint.
-         */
-        def filterByDeps(tvs0: ToInstantiate): ToInstantiate =
-          val excluded =  // ignore dependencies from other variables that are being instantiated
-            typeVarsIn(tvs0)
-          def step(tvs: ToInstantiate): ToInstantiate = tvs match
-            case tvs @ (hd @ (tvar, v)) :: tvs1 =>
-              def aboveOK = !constraint.dependsOn(tvar, excluded, co = true)
-              def belowOK = !constraint.dependsOn(tvar, excluded, co = false)
-              if v == 0 && !aboveOK then
-                step((tvar, 1) :: tvs1)
-              else if v == 0 && !belowOK then
-                step((tvar, -1) :: tvs1)
-              else if v == -1 && !aboveOK || v == 1 && !belowOK then
-                typr.println(i"drop $tvar, $v in $tp, $pt, qualifying = ${qualifying.toList}, tvs0 = ${tvs0.toList}%, %, excluded = ${excluded.toList}, $constraint")
-                step(tvs1)
-              else // no conflict, keep the instantiation proposal
-                tvs.derivedCons(hd, step(tvs1))
-            case Nil =>
-              Nil
-          val tvs1 = step(tvs0)
-          if tvs1 eq tvs0 then tvs1
-          else filterByDeps(tvs1) // filter again with smaller excluded set
-        end filterByDeps
-
-        /** Instantiate all type variables in `tvs` in the indicated directions,
-         *  as described in the doc comment of `ToInstantiate`.
-         *  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(tvs: ToInstantiate): Unit =
-
-          /** Try to instantiate `tvs`, return any suspended type variables */
-          def tryInstantiate(tvs: ToInstantiate): ToInstantiate = tvs match
-            case (hd @ (tvar, v)) :: tvs1 =>
-              val fromBelow = v == 1 || (v == 0 && tvar.hasLowerBound)
-              typr.println(
-                i"interpolate${if v == 0 then " non-occurring" else ""} $tvar in $state in $tree: $tp, fromBelow = $fromBelow, $constraint")
-              if tvar.isInstantiated then
-                tryInstantiate(tvs1)
-              else
-                val suspend = tvs1.exists{ (following, _) =>
-                  if fromBelow
-                  then constraint.isLess(following.origin, tvar.origin)
-                  else constraint.isLess(tvar.origin, following.origin)
-                }
-                if suspend then
-                  typr.println(i"suspended: $hd")
-                  hd :: tryInstantiate(tvs1)
-                else
-                  tvar.instantiate(fromBelow)
-                  tryInstantiate(tvs1)
-            case Nil => Nil
-          if tvs.nonEmpty then doInstantiate(tryInstantiate(tvs))
-        end doInstantiate
-
-        doInstantiate(filterByDeps(toInstantiate))
-      }
-    end if
-    tree
-  end interpolateTypeVars
-
-  /** 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
deleted file mode 100644
index 89caf5e1c474..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/JavaChecks.scala
+++ /dev/null
@@ -1,26 +0,0 @@
-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
deleted file mode 100644
index 8487192b9d8a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/Namer.scala
+++ /dev/null
@@ -1,1916 +0,0 @@
-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._
-import annotation.unchecked.uncheckedCaptures
-
-/** 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(em"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.detach), 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)
-          .detach
-
-        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.detach), 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): DetachedContext = {
-    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 ctx: DetachedContext): DetachedContext = {
-    def recur(stat: Tree): DetachedContext = 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)).detach
-      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, i" 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.detach)((ctx, stat) => indexExpanded(stat)(using ctx.detach))
-    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): DetachedContext =
-      val saved = lateCompile
-      lateCompile = true
-      try index(unit.untpdTree :: Nil).detach 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(em"${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: DetachedContext) 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).detach
-        for (annotTree <- original.mods.annotations) {
-          val cls = typedAheadAnnotationClass(annotTree)(using annotCtx)
-          if (cls eq sym)
-            report.error(em"An annotation class cannot be annotated with iself", annotTree.srcPos)
-          else {
-            val ann = Annotation.deferred(cls)(typedAheadExpr(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: DetachedContext)
-  extends Completer(original)(ictx) with TypeParamsCompleter {
-    private var myTypeParams: List[TypeSymbol] | Null = null
-
-    @uncheckedCaptures
-    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: DetachedContext) extends Completer(original)(ictx) {
-    withDecls(newScope(using ictx))
-
-    protected implicit val completerCtx: Context = localContext(cls)
-
-    private var localCtx: DetachedContext = _
-
-    /** 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)).collectCC {
-            case CanForward.No(whyNot) => i"\n$path.$name cannot be exported because it $whyNot"
-          }.headOption.getOrElse("")
-          report.error(em"""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(
-                  em"""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).detach
-
-      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(
-              em"""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 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
-    case TypedSplice(_) =>
-      val sym = tree.symbol
-      if sym.isConstructor then sym.owner else sym
-
-  /** 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.collectCC { 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(
-                  em"""return type ${tpt.tpe} of lambda cannot be made hygienic
-                      |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.collectCC { 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
deleted file mode 100644
index 9104418d406f..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/Nullables.scala
+++ /dev/null
@@ -1,569 +0,0 @@
-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
deleted file mode 100644
index 285f9b983cb4..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/ProtoTypes.scala
+++ /dev/null
@@ -1,958 +0,0 @@
-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, Pure {
-    def isMatchedBy(tp1: Type, keepConstraint: Boolean)(using Context): Boolean = true
-    def map(tm: TypeMap @retains(caps.cap))(using Context): ProtoType = this
-    def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.cap))(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, 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, 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 @retains(caps.cap))(using Context): SelectionProto = derivedSelectionProto(name, tm(memberProto), compat)
-    def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.cap))(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: DetachedContext)
-  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 @retains(caps.cap))(using Context): FunProto =
-      derivedFunProto(args, tm(resultType), typer)
-
-    def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.cap))(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.detach)
-  }
-
-  /** 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 DetachedContext)
-  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, 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 @retains(caps.cap))(using Context): ViewProto = derivedViewProto(tm(argType), tm(resultType))
-
-    def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.cap))(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 DetachedContext) 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 @retains(caps.cap))(using Context): PolyProto =
-      derivedPolyProto(targs, tm(resultType))
-
-    def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.cap))(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 @retains(caps.cap) | 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
deleted file mode 100644
index c40631612a0a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/QuotesAndSplices.scala
+++ /dev/null
@@ -1,455 +0,0 @@
-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.
-                    |"""
-      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(em"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(em"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(
-        em"""Splice $${...} at level $level.
-            |
-            |Inline method may contain a splice at level 0 but the contents of this splice cannot have a splice.
-            |""", 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(em"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.detach).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
deleted file mode 100644
index b53b2f9ec57a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/ReTyper.scala
+++ /dev/null
@@ -1,146 +0,0 @@
-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.typeOpt).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.typeOpt))
-    untpd.cpy.UnApply(tree)(fun1, implicits1, patterns1).withType(tree.typeOpt)
-  }
-
-  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
deleted file mode 100644
index 6ff15fe2abe5..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/RefChecks.scala
+++ /dev/null
@@ -1,1783 +0,0 @@
-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(
-              em"in $clazz, multiple overloaded alternatives of ${haveDefaults.head} define default arguments${
-                  if owners.forall(_ == clazz) then "."
-                  else i".\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 DetachedContext)
-  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
-          val othersMsg = // !cc! need to make a val
-            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) =
-      err.infoString(sym, self, showLocation = sym.owner != clazz)
-    def infoStringWithLocation(sym: Symbol) =
-      err.infoString(sym, self, showLocation = true)
-
-    /* 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(core: Context ?-> String, compareTypes: Boolean = false): Message =
-        val (mtp, otp) = if compareTypes then (memberTp(self), otherTp(self)) else (NoType, NoType)
-        OverrideError(core, self, member, other, mtp, otp)
-
-      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(
-          em"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(
-              em"`override` modifier required when a Java 8 default method is re-implemented",
-              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(
-            em"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[Message] = {
-      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(em"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
deleted file mode 100644
index e253a9b6356e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/Synthesizer.scala
+++ /dev/null
@@ -1,763 +0,0 @@
-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 original 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(em"""Internal error when synthesizing sum mirror for $cls:
-                         |$msg""", 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 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 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(
-            em"""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
deleted file mode 100644
index cb7bf2f2505d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/TypeAssigner.scala
+++ /dev/null
@@ -1,546 +0,0 @@
-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((ctx: Context) => ctx.owner).find(qualifies) match {
-      case Some(c) if packageOK || !c.is(Package) =>
-        c
-      case _ =>
-        report.error(
-          if qual.isEmpty then em"$tree can be used only in a class, object, or template"
-          else em"$qual 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(em"Expected Array but was $qualType", 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 DetachedContext): 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 em"$qualType does not have a constructor"
-      else NotAMember(qualType, tree.name, kind, addendum)
-    errorType(msg, tree.srcPos)
-
-  def inaccessibleErrorType(tpe: NamedType, superAccess: Boolean, pos: SrcPos)(using Context): Type =
-    if tpe.isError then tpe
-    else errorType(CannotBeAccessed(tpe, superAccess), 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(em"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(em"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(em"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.takesNoParamsMsg(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.takesNoParamsMsg(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
deleted file mode 100644
index 0b3f7d75f6e2..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/Typer.scala
+++ /dev/null
@@ -1,4296 +0,0 @@
-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
-import annotation.unchecked.uncheckedCaptures
-
-
-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.detach))
-          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(em"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")
-              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.detach)(using outer.detach),
-                    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: 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 =>
-      ref match
-        case OrNull(tpnn) => tree.cast(AndType(ref, tpnn))
-        case _            => tree
-    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(
-            em"""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, em"$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, em"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 constructor, 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], DetachedContext) =
-    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: Context ?-> 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(
-        em"""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(em"$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)(using null)
-        // !cc! explicit default argument required
-  }
-
-  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(em"result type of lambda is an underspecified SAM type $pt", tree.srcPos)
-                    pt
-                TypeTree(targetTpe)
-              case _ =>
-                if (mt.isParamDependent)
-                  errorTree(tree,
-                    em"""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 = {
-    @uncheckedCaptures 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] =
-    @uncheckedCaptures 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 DetachedContext) = 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.collectCC { 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(em"<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(em"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, em"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, em"Not yet implemented: T(...)")
-        else
-          return errorTree(tree, dependentMsg)
-      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 tycon == defn.IntoType then
-        // <into> is defined in package scala but this should be hidden from user programs
-        report.error(em"not found: <into>", tpt1.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, em"Not yet implemented: (...) =>> ...")
-    else
-      errorTree(tree, dependentMsg)
-
-  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, em"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.detach.outersIterator.dropWhile(c => isInner(c.owner)).next().detach
-    var adjusted: DetachedContext = outer.property(ExprOwner) match {
-      case Some(exprOwner) if outer.owner.isClass => outer.exprContext(mdef, exprOwner).detach
-      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*)).detach
-      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).detach
-    // 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 =
-    checkAnnotClass(checkAnnotArgs(typed(annot)))
-
-  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.detach.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(
-          em"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(em"$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(em"$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
-        // Annotations are represented as traits with constructors, but should
-        // never be called as such outside of annotation trees.
-        && !psym.is(JavaAnnotation)
-        && (!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 em"package ${tree.pid.name} does not exist")
-  end typedPackageDef
-
-  def typedAnnotated(tree: untpd.Annotated, pt: Type)(using Context): Tree = {
-    val annot1 = checkAnnotClass(typedExpr(tree.annot))
-    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(
-        em"""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, if ctx.mode.is(Mode.Pattern) then pt else 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(
-                    em"`?` 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.InferredTypeTree(), 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], DetachedContext) = {
-    val buf = new mutable.ListBuffer[Tree]
-    var enumContexts: SimpleIdentityMap[Symbol, DetachedContext] = 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], DetachedContext) = 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.detach)
-                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.detach)
-    }
-    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).detach)
-          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, selProto)
-              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) =
-      // get all the alternatives
-      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 %")
-
-      /** Search for an alternative that does not take parameters.
-       * If there is one, return it, otherwise emit an error.
-       */
-      def tryParameterless(alts: List[TermRef])(error: => tpd.Tree): Tree =
-        alts.filter(_.info.isParameterless) match
-          case alt :: Nil => readaptSimplified(tree.withType(alt))
-          case _ =>
-            if altDenots.exists(_.info.paramInfoss == ListOfNil) then
-              typed(untpd.Apply(untpd.TypedSplice(tree), Nil), pt, locked)
-            else
-              error
-
-      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 no 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 errorNoMatch = errorTree(tree, NoMatchingOverload(altDenots, pt))
-
-          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)(errorNoMatch)
-            case _ =>
-              tryParameterless(alts)(errorNoMatch)
-
-        case ambiAlts =>
-          // If there are ambiguous alternatives, and:
-          // 1. the types aren't erroneous
-          // 2. the expected type is not a function type
-          // 3. there exist a parameterless alternative
-          //
-          // Then, pick the parameterless alternative.
-          // See tests/pos/i10715-scala and tests/pos/i10715-java.
-
-          /** Constructs an "ambiguous overload" error */
-          def errorAmbiguous =
-            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))
-          end errorAmbiguous
-
-          if tree.tpe.isErroneous || pt.isErroneous then
-            tree.withType(UnspecifiedErrorType)
-          else
-            pt match
-              case _: FunProto =>
-                errorAmbiguous
-              case _  =>
-                tryParameterless(alts)(errorAmbiguous)
-
-      end match
-    end adaptOverloaded
-
-    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(em"${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(em"The method `apply` is inserted. The auto insertion will be deprecated, please write `$tree.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, em"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(
-              em"""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""",
-              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, pt)
-                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: Tree -> Context ?-> 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(
-              em"""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.
-                """,
-              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(em"Invalid Scala 2 macro $call", 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
deleted file mode 100644
index 60f0c043b435..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/TyperPhase.scala
+++ /dev/null
@@ -1,108 +0,0 @@
-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
deleted file mode 100644
index d035813f2e65..000000000000
--- a/tests/pos-with-compiler-cc/dotc/typer/VarianceChecker.scala
+++ /dev/null
@@ -1,209 +0,0 @@
-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
-              ""
-          em"${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(
-            msg.prepend("According to new variance rules, this is no longer accepted; need to annotate with @uncheckedVariance\n"),
-            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) = {
-      val 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(i"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
deleted file mode 100644
index d545c3631f20..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/Attachment.scala
+++ /dev/null
@@ -1,128 +0,0 @@
-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
deleted file mode 100644
index ad51702ca7f1..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/CharBuffer.scala
+++ /dev/null
@@ -1,28 +0,0 @@
-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
deleted file mode 100644
index 471b68d6247e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/Chars.scala
+++ /dev/null
@@ -1,99 +0,0 @@
-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
deleted file mode 100644
index 25def103083d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/ClasspathFromClassloader.scala
+++ /dev/null
@@ -1,53 +0,0 @@
-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
deleted file mode 100644
index b4af59c09310..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/CommentParsing.scala
+++ /dev/null
@@ -1,256 +0,0 @@
-/*
- * 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
deleted file mode 100644
index cec86fa84443..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/DiffUtil.scala
+++ /dev/null
@@ -1,234 +0,0 @@
-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
deleted file mode 100644
index f9e7e97a219d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/DotClass.scala
+++ /dev/null
@@ -1,8 +0,0 @@
-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
deleted file mode 100644
index ea049acba02b..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/EqHashMap.scala
+++ /dev/null
@@ -1,80 +0,0 @@
-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
deleted file mode 100644
index f3375028c95f..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/FreshNameCreator.scala
+++ /dev/null
@@ -1,30 +0,0 @@
-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
deleted file mode 100644
index fd6518fcc15c..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/GenericHashMap.scala
+++ /dev/null
@@ -1,192 +0,0 @@
-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
deleted file mode 100644
index aaae781c310a..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/HashMap.scala
+++ /dev/null
@@ -1,85 +0,0 @@
-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
deleted file mode 100644
index a524dd39a594..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/HashSet.scala
+++ /dev/null
@@ -1,190 +0,0 @@
-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
deleted file mode 100644
index 008ea866f70e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/IntMap.scala
+++ /dev/null
@@ -1,57 +0,0 @@
-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
deleted file mode 100644
index 99ee8a80227b..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/LRUCache.scala
+++ /dev/null
@@ -1,104 +0,0 @@
-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
deleted file mode 100644
index 28a5daaefdba..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/LinearMap.scala
+++ /dev/null
@@ -1,43 +0,0 @@
-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
deleted file mode 100644
index d057c4ebeda9..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/LinearSet.scala
+++ /dev/null
@@ -1,46 +0,0 @@
-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
deleted file mode 100644
index ba912a312aea..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/MutableMap.scala
+++ /dev/null
@@ -1,18 +0,0 @@
-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
deleted file mode 100644
index 6e3ae7628eb6..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/MutableSet.scala
+++ /dev/null
@@ -1,25 +0,0 @@
-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
deleted file mode 100644
index 61cf238fbc7f..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/NameTransformer.scala
+++ /dev/null
@@ -1,151 +0,0 @@
-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
deleted file mode 100644
index ac724f7e336f..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/ParsedComment.scala
+++ /dev/null
@@ -1,224 +0,0 @@
-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
deleted file mode 100644
index fca790837959..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/PerfectHashing.scala
+++ /dev/null
@@ -1,136 +0,0 @@
-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
deleted file mode 100644
index ebcd43ae5a11..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/Property.scala
+++ /dev/null
@@ -1,18 +0,0 @@
-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
deleted file mode 100644
index dbef59d6dee7..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/ReadOnlyMap.scala
+++ /dev/null
@@ -1,41 +0,0 @@
-package dotty.tools
-package dotc.util
-
-/** A class for the reading part of mutable or immutable maps.
- */
-abstract class ReadOnlyMap[Key, Value] extends 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
deleted file mode 100644
index 2ab59c4c6cb6..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/ReadOnlySet.scala
+++ /dev/null
@@ -1,24 +0,0 @@
-package dotty.tools.dotc.util
-
-/** A class for the readonly part of mutable sets.
- */
-abstract class ReadOnlySet[T] extends 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
deleted file mode 100644
index 75addc916b78..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/ReusableInstance.scala
+++ /dev/null
@@ -1,34 +0,0 @@
-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
deleted file mode 100644
index f85a57a8f812..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/ShowPickled.scala
+++ /dev/null
@@ -1,287 +0,0 @@
-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
deleted file mode 100644
index ddf89e7dd04d..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/Signatures.scala
+++ /dev/null
@@ -1,549 +0,0 @@
-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
deleted file mode 100644
index 2b4aa6eda48e..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/SimpleIdentityMap.scala
+++ /dev/null
@@ -1,246 +0,0 @@
-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
deleted file mode 100644
index 32851fd823d5..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/SimpleIdentitySet.scala
+++ /dev/null
@@ -1,261 +0,0 @@
-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
deleted file mode 100644
index 42286aef5d31..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/SixteenNibbles.scala
+++ /dev/null
@@ -1,28 +0,0 @@
-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
deleted file mode 100644
index 351cf4c8bf85..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/SourceFile.scala
+++ /dev/null
@@ -1,288 +0,0 @@
-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, 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
deleted file mode 100644
index 7ab565d58533..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/SourcePosition.scala
+++ /dev/null
@@ -1,104 +0,0 @@
-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, 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
deleted file mode 100644
index baf2cfa121b0..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/Spans.scala
+++ /dev/null
@@ -1,195 +0,0 @@
-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
deleted file mode 100644
index 7fa54606c572..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/StackTraceOps.scala
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * 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
deleted file mode 100644
index f04957f26400..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/Stats.scala
+++ /dev/null
@@ -1,69 +0,0 @@
-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
deleted file mode 100644
index d8c9230b9272..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/Store.scala
+++ /dev/null
@@ -1,33 +0,0 @@
-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
deleted file mode 100644
index 7b6e3b1136ff..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/Util.scala
+++ /dev/null
@@ -1,25 +0,0 @@
-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
deleted file mode 100644
index 3c23b181a041..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/WeakHashSet.scala
+++ /dev/null
@@ -1,349 +0,0 @@
-/** 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
deleted file mode 100644
index 70e0e82a7d50..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/common.scala
+++ /dev/null
@@ -1,14 +0,0 @@
-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
deleted file mode 100644
index 961be3b0aa23..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/kwords.sc
+++ /dev/null
@@ -1,18 +0,0 @@
-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
deleted file mode 100644
index 6e6328b248e3..000000000000
--- a/tests/pos-with-compiler-cc/dotc/util/lrutest.sc
+++ /dev/null
@@ -1,40 +0,0 @@
-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
deleted file mode 100644
index 1037670cae83..000000000000
--- a/tests/pos-with-compiler-cc/package.scala
+++ /dev/null
@@ -1,54 +0,0 @@
-package dotty
-
-package object tools {
-
-  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
-
-  // 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
- }

From 0293318877b981985d3d61f11dd5bef34fff753f Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Sat, 16 Nov 2024 13:47:41 +0000
Subject: [PATCH 170/306] Fix use of memberType in scaladoc

---
 scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
index d3c93aaba8c7..ee12755c7f98 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
@@ -577,7 +577,8 @@ trait ClassLikeSupport:
 
 
   def unwrapMemberInfo(c: ClassDef, symbol: Symbol): MemberInfo =
-    val baseTypeRepr = typeForClass(c).memberType(symbol)
+    val qualTypeRepr = if c.symbol.isClassDef then This(c.symbol).tpe else typeForClass(c)
+    val baseTypeRepr = qualTypeRepr.memberType(symbol)
 
     def isSyntheticEvidence(name: String) =
       if !name.startsWith(NameKinds.ContextBoundParamName.separator) then false else

From 7644ecd6a4933a1750c527a16007f5890c45d0e7 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Mon, 18 Nov 2024 10:34:32 +0100
Subject: [PATCH 171/306] Handle old given syntax where identifier and type are
 seperated by new line (#21957)

Fixes #21768

Fixes usages of `with {...}` and `= new {}` declarations presented in
tests.
---
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala | 12 ++++++++++++
 tests/pos/i21768.scala                              | 12 ++++++++++++
 2 files changed, 24 insertions(+)
 create mode 100644 tests/pos/i21768.scala

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index cd727ba8ac72..7a55690dcc21 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1017,6 +1017,18 @@ object Parsers {
              //      def f = ...
           lookahead.nextToken()
           !lookahead.isAfterLineEnd
+        } || {
+            // Support for for pre-3.6 syntax where type is put on the next line
+            // Examples:
+            //     given namedGiven:
+            //       X[T] with {}
+            //     given otherGiven:
+            //       X[T] = new X[T]{}
+          lookahead.isIdent && {
+            lookahead.nextToken()
+            skipParams()
+            lookahead.token == WITH || lookahead.token == EQUALS
+          }
         }
       }
 
diff --git a/tests/pos/i21768.scala b/tests/pos/i21768.scala
new file mode 100644
index 000000000000..85066d0cb8a6
--- /dev/null
+++ b/tests/pos/i21768.scala
@@ -0,0 +1,12 @@
+
+trait Foo[T]:
+  def foo(v: T): Unit
+
+given myFooOfInt:
+  Foo[Int] with
+  def foo(v: Int): Unit = ???
+
+given myFooOfLong:
+  Foo[Long] = new Foo[Long] {
+    def foo(v: Long): Unit = ???
+  }

From 5d5a9e6ff17a5d1980653e6fcb622dc5a2e4d082 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Mon, 18 Nov 2024 10:35:15 +0100
Subject: [PATCH 172/306] Migration rewrites for infix arguments interpreted as
 named tuples (#21949)

Best effort migration rewrites based on prior work in #21565

At this point, it's too late to deprecate named infix arguments. Let's
produce warnings instead. We accept infix arguments that might be an
argument of a named tuple, eg. `zip`, `++` or `==` - each of these takes
a single argument with NamedTuple.

---------

Co-authored-by: Som Snytt <som.snytt@gmail.com>
Co-authored-by: Matt Bovel <matthieu@bovel.net>
---
 .../tools/dotc/config/MigrationVersion.scala  |  1 +
 .../src/dotty/tools/dotc/core/StdNames.scala  |  1 +
 .../dotty/tools/dotc/parsing/Parsers.scala    | 22 ++++++++--
 .../tools/dotc/reporting/ErrorMessageID.scala |  1 +
 .../dotty/tools/dotc/reporting/messages.scala | 10 +++++
 .../tools/dotc/typer/ErrorReporting.scala     |  6 ++-
 .../dotty/tools/dotc/CompilationTests.scala   |  1 +
 .../other-new-features/named-tuples.md        |  5 ++-
 tests/neg/infix-named-args.check              | 41 +++++++++++++++++++
 tests/neg/infix-named-args.scala              | 14 +++++++
 tests/rewrites/infix-named-args.check         | 15 +++++++
 tests/rewrites/infix-named-args.scala         | 15 +++++++
 tests/warn/infix-named-args-migration.scala   | 14 +++++++
 13 files changed, 140 insertions(+), 6 deletions(-)
 create mode 100644 tests/neg/infix-named-args.check
 create mode 100644 tests/neg/infix-named-args.scala
 create mode 100644 tests/rewrites/infix-named-args.check
 create mode 100644 tests/rewrites/infix-named-args.scala
 create mode 100644 tests/warn/infix-named-args-migration.scala

diff --git a/compiler/src/dotty/tools/dotc/config/MigrationVersion.scala b/compiler/src/dotty/tools/dotc/config/MigrationVersion.scala
index 3da716abbc40..247e3f62a98d 100644
--- a/compiler/src/dotty/tools/dotc/config/MigrationVersion.scala
+++ b/compiler/src/dotty/tools/dotc/config/MigrationVersion.scala
@@ -26,6 +26,7 @@ enum MigrationVersion(val warnFrom: SourceVersion, val errorFrom: SourceVersion)
   case WithOperator extends MigrationVersion(`3.4`, future)
   case FunctionUnderscore extends MigrationVersion(`3.4`, future)
   case NonNamedArgumentInJavaAnnotation extends MigrationVersion(`3.6`, `3.6`)
+  case AmbiguousNamedTupleInfixApply extends MigrationVersion(`3.6`, never)
   case ImportWildcard extends MigrationVersion(future, future)
   case ImportRename extends MigrationVersion(future, future)
   case ParameterEnclosedByParenthesis extends MigrationVersion(future, future)
diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala
index d3e198a7e7a7..56d71c7fb57e 100644
--- a/compiler/src/dotty/tools/dotc/core/StdNames.scala
+++ b/compiler/src/dotty/tools/dotc/core/StdNames.scala
@@ -668,6 +668,7 @@ object StdNames {
     val readResolve: N          = "readResolve"
     val zero: N                 = "zero"
     val zip: N                  = "zip"
+    val `++` : N                = "++"
     val nothingRuntimeClass: N  = "scala.runtime.Nothing$"
     val nullRuntimeClass: N     = "scala.runtime.Null$"
 
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 7a55690dcc21..2bcc6ae1ce9f 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1132,9 +1132,9 @@ object Parsers {
           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)
-              }
+              migrateInfixOp(opInfo, isType):
+                atSpan(opInfo.operator.span union opInfo.operand.span union top.span):
+                  InfixOp(opInfo.operand, opInfo.operator, top)
             }
           }
           else top
@@ -1142,6 +1142,22 @@ object Parsers {
       recur(top)
     }
 
+    private def migrateInfixOp(opInfo: OpInfo, isType: Boolean)(infixOp: InfixOp): Tree = {
+      def isNamedTupleOperator = opInfo.operator.name match
+        case nme.EQ | nme.NE |  nme.eq | nme.ne | nme.`++` | nme.zip => true
+        case _ => false
+      if isType then infixOp
+      else infixOp.right match
+        case Tuple(args) if args.exists(_.isInstanceOf[NamedArg]) && !isNamedTupleOperator =>
+          report.errorOrMigrationWarning(AmbiguousNamedTupleInfixApply(), infixOp.right.srcPos, MigrationVersion.AmbiguousNamedTupleInfixApply)
+          if MigrationVersion.AmbiguousNamedTupleInfixApply.needsPatch then
+            val asApply = cpy.Apply(infixOp)(Select(opInfo.operand, opInfo.operator.name), args)
+            patch(source, infixOp.span, asApply.show(using ctx.withoutColors))
+            asApply // allow to use pre-3.6 syntax in migration mode
+          else infixOp
+        case _ => infixOp
+    }
+
     /** True if we are seeing a lambda argument after a colon of the form:
      *    : (params) =>
      *      body
diff --git a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
index 6d0a85b3ef0f..35c170858bbf 100644
--- a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
@@ -217,6 +217,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case NonNamedArgumentInJavaAnnotationID // errorNumber: 201
   case QuotedTypeMissingID // errorNumber: 202
   case AmbiguousNamedTupleAssignmentID // errorNumber: 203
+  case AmbiguousNamedTupleInfixApplyID // errorNumber: 204
 
   def errorNumber = ordinal - 1
 
diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index 3b7fba1cb52d..328ec122f848 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -3352,3 +3352,13 @@ final class AmbiguousNamedTupleAssignment(key: Name, value: untpd.Tree)(using Co
       |To assign a value, use curly braces: `{${key} = ${value}}`."""
   
   override protected def explain(using Context): String = ""
+
+class AmbiguousNamedTupleInfixApply()(using Context) extends SyntaxMsg(AmbiguousNamedTupleInfixApplyID):
+  def msg(using Context) =
+    "Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list."
+    + Message.rewriteNotice("This", version = SourceVersion.`3.6-migration`)
+
+  def explain(using Context) =
+    i"""Starting with Scala 3.6 infix named arguments are interpretted as Named Tuple.
+        |
+        |To avoid this warning, either remove the argument names or use dotted selection."""
diff --git a/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala b/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala
index 68143dfd2ba0..13e75be75838 100644
--- a/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala
@@ -110,7 +110,11 @@ object ErrorReporting {
             case tp => i" and expected result type $tp"
           }
           i"(${tp.typedArgs().tpes}%, %)$result"
-        s"arguments ${argStr(tp)}"
+        def hasNames = tp.args.exists:
+          case tree: untpd.Tuple => tree.trees.exists(_.isInstanceOf[NamedArg])
+          case _ => false
+        val addendum = if hasNames then " (a named tuple)" else ""
+        s"arguments ${argStr(tp)}$addendum"
       case _ =>
         i"expected type $tp"
     }
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index de00faa86406..3bd3b5138fad 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -79,6 +79,7 @@ class CompilationTests {
       compileFile("tests/rewrites/i20002.scala", defaultOptions.and("-indent", "-rewrite")),
       compileDir("tests/rewrites/annotation-named-pararamters", defaultOptions.and("-rewrite", "-source:3.6-migration")),
       compileFile("tests/rewrites/i21418.scala", unindentOptions.and("-rewrite", "-source:3.5-migration")),
+      compileFile("tests/rewrites/infix-named-args.scala", defaultOptions.and("-rewrite", "-source:3.6-migration")),
     ).checkRewrites()
   }
 
diff --git a/docs/_docs/reference/other-new-features/named-tuples.md b/docs/_docs/reference/other-new-features/named-tuples.md
index df96a91fe182..5483c5cc255b 100644
--- a/docs/_docs/reference/other-new-features/named-tuples.md
+++ b/docs/_docs/reference/other-new-features/named-tuples.md
@@ -17,8 +17,9 @@ val persons: List[Person] = ...
 val minors = persons.filter: p =>
   p.age < 18
 ```
-Named bindings in tuples are similar to function parameters and arguments. We use `name: Type` for element types and `name = value` for element values. It is illegal to mix named and unnamed elements in a tuple, or to use the same same
-name for two different elements.
+Named bindings in tuples are similar to function parameters and arguments.
+We use `name: Type` for element types and `name = value` for element values.
+It is illegal to mix named and unnamed elements in a tuple, or to use the same name for two different elements.
 
 Fields of named tuples can be selected by their name, as in the line `p.age < 18` above.
 
diff --git a/tests/neg/infix-named-args.check b/tests/neg/infix-named-args.check
new file mode 100644
index 000000000000..0cfbbaef73a3
--- /dev/null
+++ b/tests/neg/infix-named-args.check
@@ -0,0 +1,41 @@
+-- [E134] Type Error: tests/neg/infix-named-args.scala:2:13 ------------------------------------------------------------
+2 |  def f = 42 + (x = 1) // error // werror
+  |          ^^^^
+  |          None of the overloaded alternatives of method + in class Int with types
+  |           (x: Double): Double
+  |           (x: Float): Float
+  |           (x: Long): Long
+  |           (x: Int): Int
+  |           (x: Char): Int
+  |           (x: Short): Int
+  |           (x: Byte): Int
+  |           (x: String): String
+  |          match arguments ((x : Int)) (a named tuple)
+-- [E204] Syntax Warning: tests/neg/infix-named-args.scala:2:15 --------------------------------------------------------
+2 |  def f = 42 + (x = 1) // error // werror
+  |               ^^^^^^^
+  |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
+  |This can be rewritten automatically under -rewrite -source 3.6-migration.
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E204] Syntax Warning: tests/neg/infix-named-args.scala:5:26 --------------------------------------------------------
+5 |  def g = new C() `multi` (x = 42, y = 27) // werror
+  |                          ^^^^^^^^^^^^^^^^
+  |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
+  |This can be rewritten automatically under -rewrite -source 3.6-migration.
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E204] Syntax Warning: tests/neg/infix-named-args.scala:6:21 --------------------------------------------------------
+6 |  def h = new C() ** (x = 42, y = 27) // werror
+  |                     ^^^^^^^^^^^^^^^^
+  |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
+  |This can be rewritten automatically under -rewrite -source 3.6-migration.
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E204] Syntax Warning: tests/neg/infix-named-args.scala:13:18 -------------------------------------------------------
+13 |  def f = this ** (x = 2) // werror
+   |                  ^^^^^^^
+   |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
+   |This can be rewritten automatically under -rewrite -source 3.6-migration.
+   |
+   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/infix-named-args.scala b/tests/neg/infix-named-args.scala
new file mode 100644
index 000000000000..d8616899540c
--- /dev/null
+++ b/tests/neg/infix-named-args.scala
@@ -0,0 +1,14 @@
+class C:
+  def f = 42 + (x = 1) // error // werror
+  def multi(x: Int, y: Int): Int = x + y
+  def **(x: Int, y: Int): Int = x + y
+  def g = new C() `multi` (x = 42, y = 27) // werror
+  def h = new C() ** (x = 42, y = 27) // werror
+
+type X = (x: Int)
+
+class D(d: Int):
+  def **(x: Int): Int = d * x
+  def **(x: X): Int = d * x.x
+  def f = this ** (x = 2) // werror
+  def g = this ** 2
diff --git a/tests/rewrites/infix-named-args.check b/tests/rewrites/infix-named-args.check
new file mode 100644
index 000000000000..a50593ef18a8
--- /dev/null
+++ b/tests/rewrites/infix-named-args.check
@@ -0,0 +1,15 @@
+class C:
+  def multi(x: Int, y: Int): Int = x + y
+  def **(x: Int, y: Int): Int = x + y
+  def g = new C().multi(x = 42, y = 27)
+  def h = new C().**(x = 42, y = 27)
+
+type X = (x: Int)
+
+class D(d: Int):
+  def **(x: Int): Int = d * x
+  def **(x: X): Int = d * x.x
+  def f = this.**(x = 2)
+  def g = this ** 2
+  def h = this ** ((x = 2))
+  def i = this.**(x = (1 + 1))
\ No newline at end of file
diff --git a/tests/rewrites/infix-named-args.scala b/tests/rewrites/infix-named-args.scala
new file mode 100644
index 000000000000..bcdf4a21a9d2
--- /dev/null
+++ b/tests/rewrites/infix-named-args.scala
@@ -0,0 +1,15 @@
+class C:
+  def multi(x: Int, y: Int): Int = x + y
+  def **(x: Int, y: Int): Int = x + y
+  def g = new C() `multi` (x = 42, y = 27)
+  def h = new C() ** (x = 42, y = 27)
+
+type X = (x: Int)
+
+class D(d: Int):
+  def **(x: Int): Int = d * x
+  def **(x: X): Int = d * x.x
+  def f = this ** (x = 2)
+  def g = this ** 2
+  def h = this ** ((x = 2))
+  def i = this ** (x = (1 + 1))
diff --git a/tests/warn/infix-named-args-migration.scala b/tests/warn/infix-named-args-migration.scala
new file mode 100644
index 000000000000..df4bfb50271c
--- /dev/null
+++ b/tests/warn/infix-named-args-migration.scala
@@ -0,0 +1,14 @@
+//> using options -source:3.6-migration
+class C:
+  def f = 42 + (x = 1) // warn // interpreted as 42.+(x = 1) under migration, x is a valid synthetic parameter name
+  def multi(x: Int, y: Int): Int = x + y
+  def **(x: Int, y: Int): Int = x + y
+  def g = new C() `multi` (x = 42, y = 27) // warn
+  def h = new C() ** (x = 42, y = 27) // warn
+
+type X = (x: Int)
+
+class D(d: Int):
+  def **(x: Int): Int = d * x
+  def f = this ** (x = 2) // warn
+  def g = this ** 2

From 6e286792efd1336c3902dea567be1250a9242a3c Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Mon, 18 Nov 2024 12:46:49 +0100
Subject: [PATCH 173/306] Don't explicitly check for error trees in export
 selectors

---
 compiler/src/dotty/tools/dotc/typer/Namer.scala | 2 +-
 tests/neg/i20511.check                          | 6 ++++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 5b8cac9b1684..83964417a6f1 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -1131,7 +1131,7 @@ class Namer { typer: Typer =>
     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 || selectors.exists(_.imported.name == nme.ERROR) then
+      if expr.isEmpty then
         report.error(em"Export selector must have prefix and `.`", exp.srcPos)
         return Nil
 
diff --git a/tests/neg/i20511.check b/tests/neg/i20511.check
index 27c8126d43ab..fefff9f42a6f 100644
--- a/tests/neg/i20511.check
+++ b/tests/neg/i20511.check
@@ -6,7 +6,9 @@
 8 |val i = 1 // error
   |^^^
   |'.' expected, but 'end of statement' found
--- Error: tests/neg/i20511.scala:7:21 ----------------------------------------------------------------------------------
+-- [E083] Type Error: tests/neg/i20511.scala:7:21 ----------------------------------------------------------------------
 7 |export toppingPrice, crustPrice // error // error
   |                     ^^^^^^^^^^
-  |                     Export selector must have prefix and `.`
+  |                     Any is not a valid export prefix, since it is not an immutable path
+  |
+  | longer explanation available when compiling with `-explain`

From d64766fce91cca6a30a4949f5a7ca33dd40e19b3 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 18 Nov 2024 13:12:49 +0000
Subject: [PATCH 174/306] Relax method signature matching under
 Mode.CheckBoundsOrSelfType

---
 .../tools/dotc/core/CheckRealizable.scala     |   4 +-
 .../dotty/tools/dotc/core/TypeComparer.scala  |   7 +-
 tests/pos/i17222.izumi.min.scala              |   7 +
 .../pos/i17222.izumi.rep/InspectorBase.scala  |  59 ++++
 .../pos/i17222.izumi.rep/ReflectionUtil.scala | 331 ++++++++++++++++++
 5 files changed, 405 insertions(+), 3 deletions(-)
 create mode 100644 tests/pos/i17222.izumi.min.scala
 create mode 100644 tests/pos/i17222.izumi.rep/InspectorBase.scala
 create mode 100644 tests/pos/i17222.izumi.rep/ReflectionUtil.scala

diff --git a/compiler/src/dotty/tools/dotc/core/CheckRealizable.scala b/compiler/src/dotty/tools/dotc/core/CheckRealizable.scala
index d8241f3ff304..81b03d765676 100644
--- a/compiler/src/dotty/tools/dotc/core/CheckRealizable.scala
+++ b/compiler/src/dotty/tools/dotc/core/CheckRealizable.scala
@@ -131,8 +131,8 @@ class CheckRealizable(using Context) {
   /** `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 type members have good bounds
+   *    - all refinements of the underlying type have good bounds
    *    - 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.
diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 9cef4148747e..8414c3795f49 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -2134,11 +2134,16 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       // 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 knowing precise parameter signatures. One can signal
-      // this by inheriting from the `scala.reflect.SignatureCanBeImprecise` marker trait,
+      // this by inheriting from the `scala.Selectable.WithoutPreciseParameterTypes` marker trait,
       // in which case the signature test is elided.
+      // We also relax signature checking when checking bounds,
+      // for instance in tests/pos/i17222.izumi.min.scala
+      // the `go` method info as seen from `Foo` is `>: (in: Any): Unit <: (Nothing): Unit`
+      // So the parameter types conform but their signatures don't match.
       def sigsOK(symInfo: Type, info2: Type) =
         tp2.underlyingClassRef(refinementOK = true).member(name).exists
         || tp2.derivesFrom(defn.WithoutPreciseParameterTypesClass)
+        || ctx.mode.is(Mode.CheckBoundsOrSelfType)
         || symInfo.isInstanceOf[MethodType]
             && symInfo.signature.consistentParams(info2.signature)
 
diff --git a/tests/pos/i17222.izumi.min.scala b/tests/pos/i17222.izumi.min.scala
new file mode 100644
index 000000000000..06eadca73130
--- /dev/null
+++ b/tests/pos/i17222.izumi.min.scala
@@ -0,0 +1,7 @@
+class Foo:
+  type In
+  type Bar = { def go(in: In): Unit }
+  type False = false
+
+class Test:
+  def t1: Unit = valueOf[Foo#False]
diff --git a/tests/pos/i17222.izumi.rep/InspectorBase.scala b/tests/pos/i17222.izumi.rep/InspectorBase.scala
new file mode 100644
index 000000000000..56075831898d
--- /dev/null
+++ b/tests/pos/i17222.izumi.rep/InspectorBase.scala
@@ -0,0 +1,59 @@
+package izumi.reflect.dottyreflection
+
+import scala.quoted.Quotes
+
+trait InspectorBase extends ReflectionUtil {
+
+  val qctx: Quotes
+  import qctx.reflect._
+
+  protected def shift: Int
+
+  // FIXME reimplement TrivialMacroLogger on Scala 3
+  inline def debug: debug = valueOf[debug]
+  final type debug = false
+
+  // println instead of report.info because report.info eats all the subsequent report.info's after first.
+  inline final protected def logStart(inline s: String): Unit = {
+    inline if (debug) println(" " * shift + currentPositionStr + s)
+  }
+
+  inline final protected def log(inline s: String): Unit = {
+    inline if (debug) println(" " * shift + currentPositionStr + " -> " + s)
+  }
+
+  inline final protected def logTpeAttrs[T](inline typeRepr: TypeRepr): Unit = {
+    inline if (debug) {
+      val tree = TypeTree.of(using typeRepr.asType)
+      val symbol = tree.symbol
+      System
+        .err.println(
+          currentPositionStr + ": " +
+          s"Attrs[${tree.show}]: type=${symbol.isType}, term=${symbol.isTerm}, packageDef=${symbol.isPackageDef}, classDef=${symbol.isClassDef}, typeDef=${symbol.isValDef}, defdef=${symbol.isDefDef}, bind=${symbol.isBind}, nosymbol=${symbol.isNoSymbol}"
+        )
+    }
+  }
+
+  private def currentPositionStr: String = {
+    val pos = qctx.reflect.Position.ofMacroExpansion
+    s"${pos.sourceFile.name}:${pos.endLine}"
+  }
+
+}
+
+object InspectorBase {
+
+  private[reflect] inline def ifDebug[A](inline f: => Unit): Unit = {
+    inline if (valueOf[InspectorBase#debug]) {
+//[error]              ^^^^^^^^^^^^^
+//[error] izumi.reflect.dottyreflection.InspectorBase is not a legal path
+//[error] since it has a member InternalTypeRefOrParamRef with possibly conflicting bounds Object{def underlying(ctx: Any): Nothing} <: ... <: Object{def underlying(ctx: Nothing): Matchable}
+      f
+    }
+  }
+
+  private[reflect] inline def log(inline shift: Int, s: String): Unit = {
+    inline if (valueOf[InspectorBase#debug]) println(" " * shift + " -> " + s)
+  }
+
+}
diff --git a/tests/pos/i17222.izumi.rep/ReflectionUtil.scala b/tests/pos/i17222.izumi.rep/ReflectionUtil.scala
new file mode 100644
index 000000000000..c8ff667191af
--- /dev/null
+++ b/tests/pos/i17222.izumi.rep/ReflectionUtil.scala
@@ -0,0 +1,331 @@
+package izumi.reflect.dottyreflection
+
+import scala.annotation.{tailrec, unused}
+import scala.collection.immutable.Queue
+import scala.quoted.Quotes
+
+private[dottyreflection] trait ReflectionUtil { this: InspectorBase =>
+
+  import qctx.reflect.*
+
+  private final lazy val ignoredInIntersections0: Set[TypeRepr] = {
+    Set(
+      defn.AnyClass.typeRef,
+      defn.MatchableClass.typeRef,
+      defn.AnyRefClass.typeRef,
+      defn.ObjectClass.typeRef
+    )
+  }
+  def ignoredInIntersections(repr: qctx.reflect.TypeRepr): Boolean = {
+    ignoredInIntersections0.exists(_ =:= repr)
+  }
+  def ignoredInUnions(repr: qctx.reflect.TypeRepr): Boolean = {
+    repr =:= defn.NothingClass.typeRef
+  }
+
+  protected final def flattenAnd(tpe: TypeRepr): List[TypeRepr] =
+    tpe.dealias match {
+      case AndType(lhs, rhs) => flattenAnd(lhs) ++ flattenAnd(rhs)
+      case _ => List(tpe)
+    }
+
+  protected final def flattenOr(tpe: TypeRepr): List[TypeRepr] =
+    tpe.dealias match {
+      case OrType(lhs, rhs) => flattenOr(lhs) ++ flattenOr(rhs)
+      case _ => List(tpe)
+    }
+
+  protected final def intersectionUnionRefinementClassPartsOf(tpe: TypeRepr): List[TypeRepr] = {
+    tpe.dealias match {
+      case AndType(lhs, rhs) =>
+        intersectionUnionRefinementClassPartsOf(lhs) ++ intersectionUnionRefinementClassPartsOf(rhs)
+      case OrType(lhs, rhs) =>
+        intersectionUnionRefinementClassPartsOf(lhs) ++ intersectionUnionRefinementClassPartsOf(rhs)
+      case refinement: Refinement =>
+        intersectionUnionRefinementClassPartsOf(refinement.parent)
+      case _ =>
+        List(tpe)
+    }
+  }
+
+  protected final def refinementInfoToParts(tpe0: TypeRepr): List[TypeRepr] = {
+    tpe0 match {
+      case ByNameType(tpe) =>
+        refinementInfoToParts(tpe)
+      case MethodType(_, args, res) =>
+        args.flatMap(refinementInfoToParts) ++ refinementInfoToParts(res)
+      case PolyType(_, tbounds, res) =>
+        // FIXME we need to do FullDbInspector.inspectTypeReprToFullBases.lambdify/LightTypeTagImpl.makeLambdaOnlyBases.makeLambdaParents
+        //   to wrap the unresolved type params in `res` into a lambda.
+        //   As is, if type parameters are used in `res`, we'll add lots of trash types into db
+        tbounds.flatMap { case TypeBounds(lo, hi) => List(lo, hi) } ++ refinementInfoToParts(res)
+      case tpe =>
+        List(tpe)
+    }
+  }
+
+  protected final def flattenRefinements(ref: Refinement): (Queue[(Symbol, String, TypeRepr)], TypeRepr) = {
+    val refinementDecl = (ref.typeSymbol, ref.name, ref.info)
+    ref.parent match {
+      case innerRefinement: Refinement =>
+        val (innerRefs, nonRefinementParent) = flattenRefinements(innerRefinement)
+        (innerRefs :+ refinementDecl, nonRefinementParent)
+      case nonRefinementParent =>
+        (Queue(refinementDecl), nonRefinementParent)
+    }
+  }
+
+  protected final def allPartsStrong(outerOwnerClassDefs: Set[Symbol], typeRepr: TypeRepr): Boolean = {
+    ReflectionUtil.allPartsStrong(using qctx)(shift, outerOwnerClassDefs, Set.empty, typeRepr)
+  }
+
+  protected final def getClassDefOwners(symbol: Symbol): Set[Symbol] = {
+    ReflectionUtil.getClassDefOwners(using qctx)(symbol)
+  }
+
+  import ReflectionUtil.reflectiveUncheckedNonOverloadedSelectable
+  import InternalContext.InternalContext
+
+  extension (typeRef: TypeRef | ParamRef) {
+    protected final def _underlying: TypeRepr = {
+      // This works as a substitution for `TypeRef#underlying` call,
+      // but I'm not sure if it's a reliable substitution.
+
+//      typeRef.typeSymbol.owner._typeRef.memberType(typeRef.typeSymbol)
+
+      // No, It's not a reliable substitution. When used on a TypeParamRef it returns Any instead of the underlying TypeBounds
+      // https://github.com/lampepfl/dotty/issues/15799
+
+//      val underlying = typeRef
+//        .getClass.getMethods.collect { case m if m.getName == "underlying" => m }.head.invoke(
+//          typeRef,
+//          qctx.getClass.getMethods.collect { case m if m.getName == "ctx" => m }.head.invoke(qctx)
+//        )
+//      underlying.asInstanceOf[TypeRepr]
+
+      typeRef.asInstanceOf[InternalTypeRefOrParamRef].underlying(qctx._ctx)
+    }
+  }
+
+  extension (typeRepr: TypeRepr) {
+    protected final def _paramVariancesIfHKTypeLambda: Option[List[Flags]] = {
+      try {
+        val params = typeRepr.asInstanceOf[InternalHKTypeLambda].typeParams
+        val flags = params.map(_.paramVariance(qctx._ctx))
+        Some(flags)
+      } catch {
+        case _: NoSuchMethodException => None
+      }
+    }
+
+    @tailrec
+    protected final def _dealiasSimplifiedFull: TypeRepr = {
+//      val res = typeRepr.dealias.simplified
+      // simplified does everything below functions do, with exception of `_removeTautologicalUnions` for some reason
+      // All of these would be more useful, if not for forced type simplification on implicit macro - https://github.com/lampepfl/dotty/issues/17544
+      val res = typeRepr.dealias._removeTautologicalIntersections._removeTautologicalUnions._simplifyMatchCase
+      if (res.asInstanceOf[AnyRef] eq typeRepr.asInstanceOf[AnyRef]) {
+        res
+      } else {
+        res._dealiasSimplifiedFull
+      }
+    }
+
+    // Calling .simplified will remove too many intersections - we only want to remove those with Any/AnyRef/Object/Matchable
+    @tailrec private def _removeTautologicalIntersections: TypeRepr = {
+      typeRepr match {
+        case AndType(a, b) =>
+          if (ignoredInIntersections(a)) {
+            b._removeTautologicalIntersections
+          } else if (ignoredInIntersections(b)) {
+            a._removeTautologicalIntersections
+          } else {
+            removeTautologicalIntersectionsNonTailRec(a, b)
+          }
+        case _ =>
+          typeRepr
+      }
+    }
+
+    private def removeTautologicalIntersectionsNonTailRec(a: TypeRepr, b: TypeRepr): TypeRepr = {
+      val a0 = a._removeTautologicalIntersections
+      val b0 = b._removeTautologicalIntersections
+      if ((a.asInstanceOf[AnyRef] ne a0.asInstanceOf[AnyRef]) || (b.asInstanceOf[AnyRef] ne b0.asInstanceOf[AnyRef])) {
+        AndType(a0, b0)
+      } else {
+        typeRepr
+      }
+    }
+
+    @tailrec private def _removeTautologicalUnions: TypeRepr = {
+      typeRepr match {
+        case OrType(a, b) =>
+          if (ignoredInUnions(a)) {
+            b._removeTautologicalUnions
+          } else if (ignoredInUnions(b)) {
+            a._removeTautologicalUnions
+          } else {
+            removeTautologicaUnionsNonTailRec(a, b)
+          }
+        case _ =>
+          typeRepr
+      }
+    }
+
+    private def removeTautologicaUnionsNonTailRec(a: TypeRepr, b: TypeRepr): TypeRepr = {
+      val superA = ignoredInIntersections(a)
+      val superB = ignoredInIntersections(b)
+      if (superA && superB) {
+        (if (a <:< b) b else a)._removeTautologicalUnions
+      } else if (superA) {
+        a
+      } else if (superB) {
+        b
+      } else {
+        val a0 = a._removeTautologicalUnions
+        val b0 = b._removeTautologicalUnions
+        if ((a.asInstanceOf[AnyRef] ne a0.asInstanceOf[AnyRef]) || (b.asInstanceOf[AnyRef] ne b0.asInstanceOf[AnyRef])) {
+          AndType(a0, b0)
+        } else {
+          typeRepr
+        }
+      }
+    }
+
+    inline private def _simplifyMatchCase: TypeRepr = {
+      typeRepr match {
+        case _: MatchCase | _: MatchType =>
+          // no other way to evaluate a match type other than calling simplified,
+          // even though that'll also cause a collapse of tautological intersections
+          // other than with Any/AnyRef/Object/Matchable
+          typeRepr.simplified
+        case _ =>
+          typeRepr
+      }
+    }
+
+  }
+
+  extension (qctx: Quotes) {
+    final def _ctx: InternalContext = qctx.asInstanceOf[{ def ctx: InternalContext }].ctx
+  }
+
+  type InternalTypeRefOrParamRef = {
+    def underlying(ctx: InternalContext): TypeRepr
+  }
+
+  type InternalHKTypeLambda = {
+    val typeParams: List[InternalLambdaParam]
+  }
+
+  type InternalLambdaParam = {
+    def paramVariance(ctx: InternalContext): Flags
+  }
+
+  object InternalContext {
+    opaque type InternalContext = Any
+  }
+
+}
+
+private[reflect] object ReflectionUtil {
+
+  private[reflect] inline implicit def reflectiveUncheckedNonOverloadedSelectable(x: Any): UncheckedNonOverloadedSelectable = new UncheckedNonOverloadedSelectable(x)
+
+  /**
+    * Returns true if the given type contains no type parameters
+    * (this means the type is not "weak" https://stackoverflow.com/questions/29435985/weaktypetag-v-typetag)
+    */
+  private[reflect] def allPartsStrong(
+    using qctx: Quotes
+  )(shift: Int,
+    outerOwnerClassDefs: Set[qctx.reflect.Symbol],
+    outerLambdas: Set[qctx.reflect.TypeRepr],
+    typeRepr: qctx.reflect.TypeRepr
+  ): Boolean = {
+    import qctx.reflect.*
+    typeRepr.dealias match {
+      case x if topLevelWeakType(outerOwnerClassDefs, outerLambdas, x) => false
+      case AppliedType(tpe, args) =>
+        allPartsStrong(shift, outerOwnerClassDefs, outerLambdas, tpe) && args.forall(allPartsStrong(shift, outerOwnerClassDefs, outerLambdas, _))
+      case AndType(lhs, rhs) => allPartsStrong(shift, outerOwnerClassDefs, outerLambdas, lhs) && allPartsStrong(shift, outerOwnerClassDefs, outerLambdas, rhs)
+      case OrType(lhs, rhs) => allPartsStrong(shift, outerOwnerClassDefs, outerLambdas, lhs) && allPartsStrong(shift, outerOwnerClassDefs, outerLambdas, rhs)
+      case TypeRef(tpe, _) => allPartsStrong(shift, outerOwnerClassDefs, outerLambdas, tpe)
+      case TermRef(tpe, _) => allPartsStrong(shift, outerOwnerClassDefs, outerLambdas, tpe)
+      case ThisType(tpe) => allPartsStrong(shift, outerOwnerClassDefs, outerLambdas, tpe)
+      case NoPrefix() => true
+      case TypeBounds(lo, hi) => allPartsStrong(shift, outerOwnerClassDefs, outerLambdas, lo) && allPartsStrong(shift, outerOwnerClassDefs, outerLambdas, hi)
+      case lam @ TypeLambda(_, _, body) => allPartsStrong(shift, outerOwnerClassDefs, outerLambdas + lam, body)
+      case Refinement(parent, _, tpe) => allPartsStrong(shift, outerOwnerClassDefs, outerLambdas, tpe) && allPartsStrong(shift, outerOwnerClassDefs, outerLambdas, parent)
+      case ByNameType(tpe) => allPartsStrong(shift, outerOwnerClassDefs, outerLambdas, tpe)
+      case strange =>
+        InspectorBase.log(shift, s"Got unknown type component when checking strength: $strange")
+        true
+    }
+  }
+
+  private[reflect] def topLevelWeakType(
+    using qctx: Quotes
+  )(outerOwnerClassDefs: Set[qctx.reflect.Symbol],
+    outerLambdas: Set[qctx.reflect.TypeRepr],
+    typeRepr: qctx.reflect.TypeRepr
+  ): Boolean = {
+    import qctx.reflect.*
+    typeRepr match {
+      case x if x.typeSymbol.isTypeParam =>
+        x match {
+          case t: ParamRef if outerLambdas.contains(t.binder) => false
+          case _ => true
+        }
+      // we regard abstract types like T in trait X { type T; Tag[this.T] } - when we are _inside_ the definition template
+      // as 'type parameters' too. So that you could define `implicit def tagForT: Tag[this.T]` and the tag would be resolved
+      // to this implicit correctly, instead of generating a useless `X::this.type::T` tag.
+      // TODO: Due to https://github.com/lampepfl/dotty/issues/16107 not being fixed we have to make sure we're actually
+      //       inside the definition of the this-type prefix to count it as 'weak' - unlike Scala 2 we're not protected
+      //       from this-types leaking in and have to carry the owner chain here - until that issue is fixed.
+      case x @ TypeRef(ThisType(prefix), _) if x.typeSymbol.isAbstractType && !x.typeSymbol.isClassDef && outerOwnerClassDefs.contains(prefix.typeSymbol) =>
+        true
+      case _ => false
+    }
+  }
+
+  private[reflect] def getClassDefOwners(using qctx: Quotes)(symbol: qctx.reflect.Symbol): Set[qctx.reflect.Symbol] = {
+    Iterator
+      .iterate(symbol) {
+        s =>
+          val owner = s.owner
+          if (owner == null || owner.isNoSymbol || owner == qctx.reflect.defn.RootClass) {
+            null.asInstanceOf[qctx.reflect.Symbol]
+          } else {
+            owner
+          }
+      }
+      .takeWhile(_ ne null)
+      .filter(s => s.isClassDef && !s.isAbstractType)
+      .toSet
+  }
+
+  private[reflect] final class UncheckedNonOverloadedSelectable(private val selectable: Any) extends AnyVal with Selectable {
+
+    inline def selectDynamic(name: String): Any = {
+      applyDynamic(name)()
+    }
+
+    def applyDynamic(name: String, @unused paramTypes: Class[_]*)(args: Any*): Any = {
+      val cls = selectable.getClass
+      val method = {
+        if (args.isEmpty) {
+          cls.getMethod(name)
+        } else {
+          cls.getMethods.collectFirst { case m if m.getName == name => m } match {
+            case Some(m) => m
+            case None => throw new NoSuchMethodException(s"No method named `$name` found in class `$cls`")
+          }
+        }
+      }
+      method.invoke(selectable, args*)
+    }
+
+  }
+
+}

From 63fbc86b87f82801dc09ab9f28ac5fe352c3de63 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 18 Nov 2024 14:23:24 +0000
Subject: [PATCH 175/306] Bump VirtusLab/scala-cli-setup from 1.5.1 to 1.5.3

Bumps [VirtusLab/scala-cli-setup](https://github.com/virtuslab/scala-cli-setup) from 1.5.1 to 1.5.3.
- [Release notes](https://github.com/virtuslab/scala-cli-setup/releases)
- [Commits](https://github.com/virtuslab/scala-cli-setup/compare/v1.5.1...v1.5.3)

---
updated-dependencies:
- dependency-name: VirtusLab/scala-cli-setup
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/lts-backport.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/lts-backport.yaml b/.github/workflows/lts-backport.yaml
index 52eb674c1c17..24d2329ed9da 100644
--- a/.github/workflows/lts-backport.yaml
+++ b/.github/workflows/lts-backport.yaml
@@ -15,7 +15,7 @@ jobs:
         with:
           fetch-depth: 0
       - uses: coursier/cache-action@v6
-      - uses: VirtusLab/scala-cli-setup@v1.5.1
+      - uses: VirtusLab/scala-cli-setup@v1.5.3
       - run: scala-cli ./project/scripts/addToBackportingProject.scala -- ${{ github.sha }}
         env:
           GRAPHQL_API_TOKEN: ${{ secrets.GRAPHQL_API_TOKEN }}

From 366eb01508266a3df290f771ee7f13e80eb38ec3 Mon Sep 17 00:00:00 2001
From: Tomasz Godzik <tgodzik@virtuslab.com>
Date: Tue, 29 Oct 2024 20:19:29 +0100
Subject: [PATCH 176/306] improvement: Update mtags to 1.4.0 and backport
 remaining changes

---
 .../pc/printer/ShortenedTypePrinter.scala     |  6 ++
 .../completion/CompletionKeywordSuite.scala   |  1 +
 .../pc/tests/completion/CompletionSuite.scala | 10 +--
 .../tests/edit/InsertInferredTypeSuite.scala  | 72 +++++++++++++++++++
 project/Build.scala                           |  4 +-
 5 files changed, 86 insertions(+), 7 deletions(-)

diff --git a/presentation-compiler/src/main/dotty/tools/pc/printer/ShortenedTypePrinter.scala b/presentation-compiler/src/main/dotty/tools/pc/printer/ShortenedTypePrinter.scala
index d9c11a5ada8c..b66fbe56fb9b 100644
--- a/presentation-compiler/src/main/dotty/tools/pc/printer/ShortenedTypePrinter.scala
+++ b/presentation-compiler/src/main/dotty/tools/pc/printer/ShortenedTypePrinter.scala
@@ -3,6 +3,7 @@ package dotty.tools.pc.printer
 import scala.collection.mutable
 import scala.meta.internal.jdk.CollectionConverters.*
 import scala.meta.internal.metals.ReportContext
+import scala.meta.internal.mtags.KeywordWrapper
 import scala.meta.pc.SymbolDocumentation
 import scala.meta.pc.SymbolSearch
 
@@ -64,6 +65,11 @@ class ShortenedTypePrinter(
 
   private val foundRenames = collection.mutable.LinkedHashMap.empty[Symbol, String]
 
+  override def nameString(name: Name): String =
+    val nameStr = super.nameString(name)
+    if (nameStr.nonEmpty) KeywordWrapper.Scala3Keywords.backtickWrap(nameStr)
+    else nameStr
+
   def getUsedRenames: Map[Symbol, String] =
     foundRenames.toMap.filter { case (k, v) => k.showName != v }
 
diff --git a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionKeywordSuite.scala b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionKeywordSuite.scala
index bf7077d47b3f..5db0cf96d9ef 100644
--- a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionKeywordSuite.scala
+++ b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionKeywordSuite.scala
@@ -433,6 +433,7 @@ class CompletionKeywordSuite extends BaseCompletionSuite:
          |given
          |extension
          |type
+         |opaque type
          |class
          |enum
          |case class
diff --git a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala
index 1d525c17bdf1..7be2ea6181ef 100644
--- a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala
+++ b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala
@@ -1136,7 +1136,7 @@ class CompletionSuite extends BaseCompletionSuite:
           |  scala@@
           |}
           |""".stripMargin,
-      """|scala <root>
+      """|scala `<root>`
          |""".stripMargin
     )
 
@@ -1726,8 +1726,8 @@ class CompletionSuite extends BaseCompletionSuite:
     check(
       """|import @@
          |""".stripMargin,
-      """|java <root>
-         |javax <root>
+      """|java `<root>`
+         |javax `<root>`
          |""".stripMargin,
       filter = _.startsWith("java")
     )
@@ -1745,8 +1745,8 @@ class CompletionSuite extends BaseCompletionSuite:
     check(
       """|export @@
          |""".stripMargin,
-      """|java <root>
-         |javax <root>
+      """|java `<root>`
+         |javax `<root>`
          |""".stripMargin,
       filter = _.startsWith("java")
     )
diff --git a/presentation-compiler/test/dotty/tools/pc/tests/edit/InsertInferredTypeSuite.scala b/presentation-compiler/test/dotty/tools/pc/tests/edit/InsertInferredTypeSuite.scala
index f12cab7e65ef..a96dd78be138 100644
--- a/presentation-compiler/test/dotty/tools/pc/tests/edit/InsertInferredTypeSuite.scala
+++ b/presentation-compiler/test/dotty/tools/pc/tests/edit/InsertInferredTypeSuite.scala
@@ -597,6 +597,78 @@ class InsertInferredTypeSuite extends BaseCodeActionSuite:
          |""".stripMargin
     )
 
+  @Test def `backticks-4` =
+  checkEdit(
+    """|case class `Foo-Foo`(i: Int)
+       |object O{
+       |  val <<foo>> = `Foo-Foo`(1)
+       |}""".stripMargin,
+    """|case class `Foo-Foo`(i: Int)
+       |object O{
+       |  val foo: `Foo-Foo` = `Foo-Foo`(1)
+       |}
+       |""".stripMargin
+  )
+
+
+  @Test def `backticks-5` =
+    checkEdit(
+      """|object A{
+         |  case class `Foo-Foo`(i: Int)
+         |}
+         |object O{
+         |  val <<foo>> = A.`Foo-Foo`(1)
+         |}""".stripMargin,
+      """|import A.`Foo-Foo`
+         |object A{
+         |  case class `Foo-Foo`(i: Int)
+         |}
+         |object O{
+         |  val foo: `Foo-Foo` = A.`Foo-Foo`(1)
+         |}
+         |""".stripMargin
+    )
+
+
+  @Test def `backticks-6` =
+    checkEdit(
+      """|object A{
+         |  case class `Foo-Foo`[A](i: A)
+         |}
+         |object O{
+         |  val <<foo>> = A.`Foo-Foo`(1)
+         |}""".stripMargin,
+      """|import A.`Foo-Foo`
+         |object A{
+         |  case class `Foo-Foo`[A](i: A)
+         |}
+         |object O{
+         |  val foo: `Foo-Foo`[Int] = A.`Foo-Foo`(1)
+         |}
+         |""".stripMargin
+    )
+
+  @Test def `backticks-7` =
+    checkEdit(
+      """|object A{
+         |  class `x-x`
+         |  case class Foo[A](i: A)
+         |}
+         |object O{
+         |  val <<foo>> = A.Foo(new A.`x-x`)
+         |}""".stripMargin,
+      """|import A.Foo
+         |import A.`x-x`
+         |object A{
+         |  class `x-x`
+         |  case class Foo[A](i: A)
+         |}
+         |object O{
+         |  val foo: Foo[`x-x`] = A.Foo(new A.`x-x`)
+         |}
+         |""".stripMargin
+    )
+
   @Test def `literal-types1` =
     checkEdit(
       """|object O {
diff --git a/project/Build.scala b/project/Build.scala
index 464ba4a86411..3fc60e67ae6a 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -372,7 +372,7 @@ object Build {
     ),
 
     // This is used to download nightly builds of the Scala 2 library in `scala2-library-bootstrapped`
-    resolvers += "scala-integration" at "https://scala-ci.typesafe.com/artifactory/scala-integration/",
+    resolvers += "scala-integration" at "https://scala-ci.typesafe.com/artifactory/scala-integration/"
   )
 
   lazy val disableDocSetting =
@@ -1434,7 +1434,7 @@ object Build {
       BuildInfoPlugin.buildInfoDefaultSettings
 
   lazy val presentationCompilerSettings = {
-    val mtagsVersion = "1.3.5"
+    val mtagsVersion = "1.4.1"
     Seq(
       libraryDependencies ++= Seq(
         "org.lz4" % "lz4-java" % "1.8.0",

From 952eff71f4b2f49ca1870b4ef568cd8da97ee1e0 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Mon, 18 Nov 2024 16:49:08 +0100
Subject: [PATCH 177/306] Cleanup context bounds for poly functions
 implementation after review

---
 .../src/dotty/tools/dotc/ast/Desugar.scala    | 50 +++++++++++++------
 1 file changed, 36 insertions(+), 14 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 6e54dee51c89..56c153498f87 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -350,11 +350,13 @@ object desugar {
         val Function(vparams: List[untpd.ValDef] @unchecked, rhs) = fun: @unchecked
         val newParamss = paramssNoContextBounds(tparams :: vparams :: Nil)
         val params = evidenceParamBuf.toList
-        if params.isEmpty then return meth
-        val boundNames = getBoundNames(params, newParamss)
-        val recur = fitEvidenceParams(params, nme.apply, boundNames)
-        val (paramsFst, paramsSnd) = recur(newParamss)
-        functionsOf((paramsFst ++ paramsSnd).filter(_.nonEmpty), rhs)
+        if params.isEmpty then
+          meth
+        else
+          val boundNames = getBoundNames(params, newParamss)
+          val recur = fitEvidenceParams(params, nme.apply, boundNames)
+          val (paramsFst, paramsSnd) = recur(newParamss)
+          functionsOf((paramsFst ++ paramsSnd).filter(_.nonEmpty), rhs)
   end elimContextBounds
 
   def addDefaultGetters(meth: DefDef)(using Context): Tree =
@@ -487,8 +489,27 @@ object desugar {
       case Ident(name: TermName) => names.contains(name)
       case _ => false
 
-  /** Fit evidence `params` into the `mparamss` parameter lists */
-  private def fitEvidenceParams(params: List[ValDef], methName: Name, boundNames: Set[TermName])(mparamss: List[ParamClause])(using Context): (List[ParamClause], List[ParamClause]) = mparamss match
+  /** Fit evidence `params` into the `mparamss` parameter lists, making sure
+   * that all parameters referencing `params` are after them.
+   * - for methods the final parameter lists are := result._1 ++ result._2
+   * - for poly functions, each element of the pair contains at most one term
+   *   parameter list
+   *
+   * @param params the evidence parameters list that should fit into `mparamss`
+   * @param methName the name of the method that `mparamss` belongs to
+   * @param boundNames the names of the evidence parameters
+   * @param mparamss the original parameter lists of the method
+   * @return a pair of parameter lists containing all parameter lists in a
+   * reference-correct order; make sure that `params` is always at the
+   * intersection of the pair elements; this is relevant, for poly functions
+   * where `mparamss` is guaranteed to have exectly one term parameter list,
+   * then each pair element will have at most one term parameter list
+   */
+  private def fitEvidenceParams(
+    params: List[ValDef],
+    methName: Name,
+    boundNames: Set[TermName]
+  )(mparamss: List[ParamClause])(using Context): (List[ParamClause], List[ParamClause]) = mparamss match
     case ValDefs(mparams) :: _ if mparams.exists(referencesName(_, boundNames)) =>
       (params :: Nil) -> mparamss
     case ValDefs(mparams @ (mparam :: _)) :: Nil if mparam.mods.isOneOf(GivenOrImplicit) =>
@@ -547,19 +568,20 @@ object desugar {
 
     val boundNames = getBoundNames(params, meth.paramss)
 
-    val recur = fitEvidenceParams(params, meth.name, boundNames)
+    val fitParams = fitEvidenceParams(params, meth.name, boundNames)
 
-    if meth.hasAttachment(PolyFunctionApply) then
-      meth.removeAttachment(PolyFunctionApply)
-      // for PolyFunctions we are limited to a single term param list, so we reuse the recur logic to compute the new parameter lists
-      // and then we add the other parameter lists as function types to the return type
-      val (paramsFst, paramsSnd) = recur(meth.paramss)
+    if meth.removeAttachment(PolyFunctionApply).isDefined then
+      // for PolyFunctions we are limited to a single term param list, so we
+      // reuse the fitEvidenceParams logic to compute the new parameter lists
+      // and then we add the other parameter lists as function types to the
+      // return type
+      val (paramsFst, paramsSnd) = fitParams(meth.paramss)
       if ctx.mode.is(Mode.Type) then
         cpy.DefDef(meth)(paramss = paramsFst, tpt = functionsOf(paramsSnd, meth.tpt))
       else
         cpy.DefDef(meth)(paramss = paramsFst, rhs = functionsOf(paramsSnd, meth.rhs))
     else
-      val (paramsFst, paramsSnd) = recur(meth.paramss)
+      val (paramsFst, paramsSnd) = fitParams(meth.paramss)
       cpy.DefDef(meth)(paramss = paramsFst ++ paramsSnd)
   end addEvidenceParams
 

From c9badbc34b84a996d50d925470462109083e755f Mon Sep 17 00:00:00 2001
From: Hamza Remmal <hamza@remmal.dev>
Date: Mon, 18 Nov 2024 17:36:25 +0100
Subject: [PATCH 178/306] Allow macro annotations to recover from suspension

---
 compiler/src/dotty/tools/dotc/inlines/Inliner.scala           | 4 +---
 .../src/dotty/tools/dotc/transform/MacroAnnotations.scala     | 4 +++-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index 103f3aac7630..67ccfc2a221d 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -1083,9 +1083,7 @@ class Inliner(val call: tpd.Tree)(using Context):
           hints.nn += i"suspension triggered by macro call to ${sym.showLocated} in ${sym.associatedFile}"
       if suspendable then
         if ctx.settings.YnoSuspendedUnits.value then
-          return ref(defn.Predef_undefined)
-            .withType(ErrorType(em"could not expand macro, suspended units are disabled by -Yno-suspended-units"))
-            .withSpan(splicePos.span)
+          return errorTree(ref(defn.Predef_undefined), em"could not expand macro, suspended units are disabled by -Yno-suspended-units", splicePos)
         else
           ctx.compilationUnit.suspend(hints.nn.toList.mkString(", ")) // this throws a SuspendException
 
diff --git a/compiler/src/dotty/tools/dotc/transform/MacroAnnotations.scala b/compiler/src/dotty/tools/dotc/transform/MacroAnnotations.scala
index 6625190661e3..fd901032de4b 100644
--- a/compiler/src/dotty/tools/dotc/transform/MacroAnnotations.scala
+++ b/compiler/src/dotty/tools/dotc/transform/MacroAnnotations.scala
@@ -127,6 +127,8 @@ object MacroAnnotations:
       //       Replace this case with the nested cases.
       case ex0: InvocationTargetException =>
         ex0.getCause match
+          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 when aborting a macro expansion with StopMacroExpansion.", annot.tree)
@@ -137,7 +139,7 @@ object MacroAnnotations:
             val stack0 = ex.getStackTrace.takeWhile(_.getClassName != this.getClass().getName())
             val stack = stack0.take(1 + stack0.lastIndexWhere(_.getMethodName == "transform"))
             val msg =
-              em"""Failed to evaluate macro.
+              em"""Failed to evaluate macro annotation '$annot'.
                   |  Caused by ${ex.getClass}: ${if (ex.getMessage == null) "" else ex.getMessage}
                   |    ${stack.mkString("\n    ")}
                   |"""

From 6896ea24de8caab99652e9f2048773b1004f697d Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 18 Nov 2024 17:54:00 +0100
Subject: [PATCH 179/306] Attempt to beta reduce only if parameter and argument
 lists have same shape

It's possible to define Functions with wrong apply methods by hand which will
give an error but pass on a function that does fails beta reduction.

Fixes #21952
---
 .../tools/dotc/transform/BetaReduce.scala     | 57 ++++++++++++-------
 .../tools/dotc/transform/InlinePatterns.scala |  8 ++-
 tests/neg/i21952.scala                        |  1 +
 3 files changed, 43 insertions(+), 23 deletions(-)
 create mode 100644 tests/neg/i21952.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
index 60c1bc7c61bb..16219055b8c0 100644
--- a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
+++ b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
@@ -76,10 +76,10 @@ object BetaReduce:
     val bindingsBuf = new ListBuffer[DefTree]
     def recur(fn: Tree, argss: List[List[Tree]]): Option[Tree] = fn match
       case Block((ddef : DefDef) :: Nil, closure: Closure) if ddef.symbol == closure.meth.symbol =>
-        Some(reduceApplication(ddef, argss, bindingsBuf))
+        reduceApplication(ddef, argss, bindingsBuf)
       case Block((TypeDef(_, template: Template)) :: Nil, Typed(Apply(Select(New(_), _), _), _)) if template.constr.rhs.isEmpty =>
         template.body match
-          case (ddef: DefDef) :: Nil => Some(reduceApplication(ddef, argss, bindingsBuf))
+          case (ddef: DefDef) :: Nil => reduceApplication(ddef, argss, bindingsBuf)
           case _ => None
       case Block(stats, expr) if stats.forall(isPureBinding) =>
         recur(expr, argss).map(cpy.Block(fn)(stats, _))
@@ -106,12 +106,22 @@ object BetaReduce:
       case _ =>
         tree
 
-  /** Beta-reduces a call to `ddef` with arguments `args` and registers new bindings */
-  def reduceApplication(ddef: DefDef, argss: List[List[Tree]], bindings: ListBuffer[DefTree])(using Context): Tree =
+  /** Beta-reduces a call to `ddef` with arguments `args` and registers new bindings.
+   *  @return optionally, the expanded call, or none if the actual argument
+   *          lists do not match in shape the formal parameters
+   */
+  def reduceApplication(ddef: DefDef, argss: List[List[Tree]], bindings: ListBuffer[DefTree])
+      (using Context): Option[Tree] =
     val (targs, args) = argss.flatten.partition(_.isType)
     val tparams = ddef.leadingTypeParams
     val vparams = ddef.termParamss.flatten
 
+    def shapeMatch(paramss: List[ParamClause], argss: List[List[Tree]]): Boolean = (paramss, argss) match
+      case (params :: paramss1, args :: argss1) if params.length == args.length =>
+        shapeMatch(paramss1, argss1)
+      case (Nil, Nil) => true
+      case _ => false
+
     val targSyms =
       for (targ, tparam) <- targs.zip(tparams) yield
         targ.tpe.dealias match
@@ -143,19 +153,26 @@ object BetaReduce:
               bindings += binding.withSpan(arg.span)
             bindingSymbol
 
-    val expansion = TreeTypeMap(
-      oldOwners = ddef.symbol :: Nil,
-      newOwners = ctx.owner :: Nil,
-      substFrom = (tparams ::: vparams).map(_.symbol),
-      substTo = targSyms ::: 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 tpe: TypeRef if tree.isTerm && tpe.derivesFrom(defn.UnitClass) && isPureExpr(tree) =>
-          cpy.Literal(tree)(Constant(()))
-        case _ => super.transform(tree)
-    }.transform(expansion)
-
-    expansion1
+    if shapeMatch(ddef.paramss, argss) then
+      // We can't assume arguments always match. It's possible to construct a
+      // function with wrong apply method by hand which causes `shapeMatch` to fail.
+      // See neg/i21952.scala
+      val expansion = TreeTypeMap(
+        oldOwners = ddef.symbol :: Nil,
+        newOwners = ctx.owner :: Nil,
+        substFrom = (tparams ::: vparams).map(_.symbol),
+        substTo = targSyms ::: 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 tpe: TypeRef if tree.isTerm && tpe.derivesFrom(defn.UnitClass) && isPureExpr(tree) =>
+            cpy.Literal(tree)(Constant(()))
+          case _ => super.transform(tree)
+      }.transform(expansion)
+
+      Some(expansion1)
+    else None
+  end reduceApplication
+end BetaReduce
\ No newline at end of file
diff --git a/compiler/src/dotty/tools/dotc/transform/InlinePatterns.scala b/compiler/src/dotty/tools/dotc/transform/InlinePatterns.scala
index 18333ae506fd..d2a72e10fcfc 100644
--- a/compiler/src/dotty/tools/dotc/transform/InlinePatterns.scala
+++ b/compiler/src/dotty/tools/dotc/transform/InlinePatterns.scala
@@ -60,9 +60,11 @@ class InlinePatterns extends MiniPhase:
         template.body match
           case List(ddef @ DefDef(`name`, _, _, _)) =>
             val bindings = new ListBuffer[DefTree]()
-            val expansion1 = BetaReduce.reduceApplication(ddef, argss, bindings)
-            val bindings1 = bindings.result()
-            seq(bindings1, expansion1)
+            BetaReduce.reduceApplication(ddef, argss, bindings) match
+              case Some(expansion1) =>
+                val bindings1 = bindings.result()
+                seq(bindings1, expansion1)
+              case None => tree
           case _ => tree
       case _ => tree
 
diff --git a/tests/neg/i21952.scala b/tests/neg/i21952.scala
new file mode 100644
index 000000000000..0365d82463c0
--- /dev/null
+++ b/tests/neg/i21952.scala
@@ -0,0 +1 @@
+val _ = (new Function[(Int, Int), Int] {def apply(a: Int, b: Int): Int = a * b})(2, 3) // error

From 8743024fbb8a2406c52872af7ef481138ed5bd68 Mon Sep 17 00:00:00 2001
From: Hamza Remmal <hamza@remmal.net>
Date: Mon, 18 Nov 2024 18:00:43 +0100
Subject: [PATCH 180/306] Drop old `-Yno-experimental` flag from test suite

---
 tests/pos-macros/i20353/Macro_1.scala | 2 +-
 tests/pos-macros/i20353/Test_2.scala  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/pos-macros/i20353/Macro_1.scala b/tests/pos-macros/i20353/Macro_1.scala
index ba1e1620c1d6..5845a33ab144 100644
--- a/tests/pos-macros/i20353/Macro_1.scala
+++ b/tests/pos-macros/i20353/Macro_1.scala
@@ -1,4 +1,4 @@
-//> using options -experimental -Yno-experimental
+//> using options -experimental
 
 import scala.annotation.{experimental, MacroAnnotation}
 import scala.quoted.*
diff --git a/tests/pos-macros/i20353/Test_2.scala b/tests/pos-macros/i20353/Test_2.scala
index ebe2bb7af4b3..ee1704b691f7 100644
--- a/tests/pos-macros/i20353/Test_2.scala
+++ b/tests/pos-macros/i20353/Test_2.scala
@@ -1,4 +1,4 @@
-//> using options -experimental -Yno-experimental
+//> using options -experimental
 
 class OuterClass:
   @Test

From 16c4a8231c7cef5568192f8feca34fd81219e9cf Mon Sep 17 00:00:00 2001
From: Hamza Remmal <hamza@remmal.dev>
Date: Mon, 18 Nov 2024 22:01:53 +0100
Subject: [PATCH 181/306] update test suite

---
 tests/neg-macros/annot-crash.check | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/neg-macros/annot-crash.check b/tests/neg-macros/annot-crash.check
index 16eb0f68bc44..0a5d573d2c0d 100644
--- a/tests/neg-macros/annot-crash.check
+++ b/tests/neg-macros/annot-crash.check
@@ -2,7 +2,7 @@
 -- Error: tests/neg-macros/annot-crash/Test_2.scala:1:0 ----------------------------------------------------------------
 1 |@crash // error
   |^^^^^^
-  |Failed to evaluate macro.
+  |Failed to evaluate macro annotation '@crash'.
   |  Caused by class scala.NotImplementedError: an implementation is missing
   |    scala.Predef$.$qmark$qmark$qmark(Predef.scala:344)
   |    crash.transform(Macro_1.scala:7)

From 30ecf0d52fd531b707f112641938e7892c7f49b5 Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Tue, 19 Nov 2024 14:36:31 +0100
Subject: [PATCH 182/306] Only retry tests on CI

---
 project/Build.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project/Build.scala b/project/Build.scala
index d742ab9ad3f4..148810d4af99 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -327,7 +327,7 @@ object Build {
         .withTestRetryConfiguration(
           config.testRetryConfiguration
             .withFlakyTestPolicy(FlakyTestPolicy.Fail)
-            .withMaxRetries(1)
+            .withMaxRetries(if (isInsideCI) 1 else 0)
             .withMaxFailures(10)
             .withClassesFilter((className, _) => !noRetryTestClasses.contains(className))
         )

From bdbb0ba8b08c3e68cbc9139acc5226bbbdc354b3 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Fri, 1 Nov 2024 13:22:47 +0100
Subject: [PATCH 183/306] Handle CapsOf in more places

---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  |  2 +-
 .../src/dotty/tools/dotc/cc/CaptureRef.scala  |  2 ++
 .../dotty/tools/dotc/cc/CheckCaptures.scala   |  2 +-
 .../src/dotty/tools/dotc/core/Types.scala     |  4 ++-
 .../captures/capture-poly.scala               | 25 +++++++++++++++++++
 5 files changed, 32 insertions(+), 3 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/capture-poly.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index aad6ca8ddeac..a9272b73e605 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -198,7 +198,7 @@ extension (tp: Type)
       || tp.isRootCapability
       ) && !tp.symbol.isOneOf(UnstableValueFlags)
     case tp: TypeRef =>
-      tp.symbol.isAbstractOrParamType && tp.derivesFrom(defn.Caps_CapSet)
+      tp.symbol.isType && tp.derivesFrom(defn.Caps_CapSet)
     case tp: TypeParamRef =>
       tp.derivesFrom(defn.Caps_CapSet)
     case AnnotatedType(parent, annot) =>
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
index 590beda42903..199114880c2b 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
@@ -140,6 +140,8 @@ trait CaptureRef extends TypeProxy, ValueType:
         case ReachCapability(x1) => x1.subsumes(y.stripReach)
         case x: TermRef => viaInfo(x.info)(subsumingRefs(_, y))
         case x: TermParamRef => subsumesExistentially(x, y)
+        case x: TypeRef if x.symbol.info.derivesFrom(defn.Caps_CapSet) =>
+          x.captureSetOfInfo.elems.exists(_.subsumes(y))
         case x: TypeRef => assumedContainsOf(x).contains(y)
         case _ => false
   end subsumes
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 77d893ad49b9..2a3cd50d0e0c 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -135,7 +135,7 @@ object CheckCaptures:
       elem match
         case CapsOfApply(arg) =>
           def isLegalCapsOfArg =
-            arg.symbol.isAbstractOrParamType && arg.symbol.info.derivesFrom(defn.Caps_CapSet)
+            arg.symbol.isType && arg.symbol.info.derivesFrom(defn.Caps_CapSet)
           if !isLegalCapsOfArg then
             report.error(
               em"""$arg is not a legal prefix for `^` here,
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 31e11487ae38..821363c74a25 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -4007,7 +4007,7 @@ object Types extends TypeUtils {
                 (compute(status, parent, theAcc) /: refs.elems) {
                   (s, ref) => ref.stripReach match
                     case tp: TermParamRef if tp.binder eq thisLambdaType => combine(s, CaptureDeps)
-                    case _ => s
+                    case tp => combine(s, compute(status, tp, theAcc))
                 }
               case _ =>
                 if tp.annot.refersToParamOf(thisLambdaType) then TrueDeps
@@ -6078,6 +6078,8 @@ object Types extends TypeUtils {
         case tp: CaptureRef =>
           if tp.isTrackableRef then tp
           else ensureTrackable(tp.underlying)
+        case tp: TypeAlias =>
+          ensureTrackable(tp.alias)
         case _ =>
           assert(false, i"not a trackable captureRef ref: $result, ${result.underlyingIterator.toList}")
       ensureTrackable(result)
diff --git a/tests/neg-custom-args/captures/capture-poly.scala b/tests/neg-custom-args/captures/capture-poly.scala
new file mode 100644
index 000000000000..a3a7a4c2a3d7
--- /dev/null
+++ b/tests/neg-custom-args/captures/capture-poly.scala
@@ -0,0 +1,25 @@
+import caps.*
+
+trait Foo extends Capability
+
+trait CaptureSet:
+  type C <: CapSet^
+
+def capturePoly[C^](a: Foo^{C^}): Foo^{C^} = a
+def capturePoly2(c: CaptureSet)(a: Foo^{c.C^}): Foo^{c.C^} = a
+
+def test =
+  val x: Foo^ = ???
+  val y: Foo^ = ???
+
+  object X extends CaptureSet:
+    type C = CapSet^{x}
+
+  val z1: Foo^{X.C^} = x
+  val z2: Foo^{X.C^} = y // error
+
+  val z3: Foo^{x} = capturePoly(x)
+  val z4: Foo^{x} = capturePoly(y) // error
+
+  val z5: Foo^{x} = capturePoly2(X)(x)
+  val z6: Foo^{x} = capturePoly2(X)(y) // error
\ No newline at end of file

From 13e443954a871da85f043b5c9649a31a892a1ff7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oliver=20Bra=C4=8Devac?= <bracevac@users.noreply.github.com>
Date: Mon, 18 Nov 2024 17:49:03 +0100
Subject: [PATCH 184/306] Report error in Setup for illegal capture refs

---
 compiler/src/dotty/tools/dotc/cc/Setup.scala | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index 3147a0f7bd47..cc456567ce8a 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -18,6 +18,7 @@ import reporting.Message
 import printing.{Printer, Texts}, Texts.{Text, Str}
 import collection.mutable
 import CCState.*
+import dotty.tools.dotc.util.NoSourcePosition
 
 /** Operations accessed from CheckCaptures */
 trait SetupAPI:
@@ -323,7 +324,11 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
               val parent2 = stripImpliedCaptureSet(parent1)
               for tpt <- tptToCheck do
                 checkWellformedLater(parent2, ann.tree, tpt)
-              CapturingType(parent2, ann.tree.toCaptureSet)
+              try
+                CapturingType(parent2, ann.tree.toCaptureSet)
+              catch case ex: IllegalCaptureRef =>
+                report.error(em"Illegal capture reference: ${ex.getMessage.nn}", tptToCheck.fold(NoSourcePosition)(_.srcPos))
+                t
             else
               t.derivedAnnotatedType(parent1, ann)
           case throwsAlias(res, exc) =>

From 20917c7a95f004ac5caad5097d5d06eb5120da77 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Tue, 19 Nov 2024 18:04:51 +0100
Subject: [PATCH 185/306] Add some tests

---
 .../captures/capset-bound.scala                | 18 ++++++++++++++++++
 tests/neg-custom-args/captures/i21868.scala    | 14 ++++++++++++++
 2 files changed, 32 insertions(+)
 create mode 100644 tests/neg-custom-args/captures/capset-bound.scala
 create mode 100644 tests/neg-custom-args/captures/i21868.scala

diff --git a/tests/neg-custom-args/captures/capset-bound.scala b/tests/neg-custom-args/captures/capset-bound.scala
new file mode 100644
index 000000000000..c00f61240dea
--- /dev/null
+++ b/tests/neg-custom-args/captures/capset-bound.scala
@@ -0,0 +1,18 @@
+import caps.*
+
+class IO
+
+case class File(io: IO^)
+
+def test(io1: IO^, io2: IO^) =
+  def f[C >: CapSet^{io1} <: CapSet^](file: File^{C^}) = ???
+  val f1: File^{io1} = ???
+  val f2: File^{io2} = ???
+  val f3: File^{io1, io2} = ???
+  f[CapSet^{io1}](f1)
+  f[CapSet^{io1}](f2) // error
+  f[CapSet^{io1}](f3) // error
+  f[CapSet^{io2}](f2) // error
+  f[CapSet^{io1, io2}](f1)
+  f[CapSet^{io1, io2}](f2)
+  f[CapSet^{io1, io2}](f3)
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/i21868.scala b/tests/neg-custom-args/captures/i21868.scala
new file mode 100644
index 000000000000..349750a2ee4b
--- /dev/null
+++ b/tests/neg-custom-args/captures/i21868.scala
@@ -0,0 +1,14 @@
+import caps.
+
+trait AbstractWrong:
+    type C <: CapSet
+    def boom(): Unit^{C^} // error
+
+trait Abstract:
+    type C <: CapSet^
+    def boom(): Unit^{C^}
+
+class Concrete extends Abstract:
+    type C = Nothing
+    def boom() = () // error
+

From 6b9266e903bb3bfd12e61d2a117c3ad4d347a327 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Tue, 19 Nov 2024 22:50:33 +0100
Subject: [PATCH 186/306] Set developedVersion to 3.6.4

---
 project/Build.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project/Build.scala b/project/Build.scala
index 148810d4af99..f5593144a631 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -106,7 +106,7 @@ object Build {
    *  Should only be referred from `dottyVersion` or settings/tasks requiring simplified version string,
    *  eg. `compatMode` or Windows native distribution version.
    */
-  val developedVersion = "3.6.3"
+  val developedVersion = "3.6.4"
 
   /** The version of the compiler including the RC prefix.
    *  Defined as common base before calculating environment specific suffixes in `dottyVersion`

From 31c9fe192611a1e4664ca6c8b41cbd04e7857cf7 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Tue, 19 Nov 2024 22:51:28 +0100
Subject: [PATCH 187/306] Set referenceVersion to 3.6.2-RC1

---
 project/Build.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project/Build.scala b/project/Build.scala
index f5593144a631..b4673405bec9 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -97,7 +97,7 @@ object Build {
    *  - In release branch it should be the last stable release
    *  3.6.0-RC1 was released as 3.6.0 - it's having and experimental TASTy version
    */
-  val referenceVersion = "3.6.0"
+  val referenceVersion = "3.6.2-RC1"
 
   /** Version of the Scala compiler targeted in the current release cycle
    *  Contains a version without RC/SNAPSHOT/NIGHTLY specific suffixes

From 2bf5df7e1a0bf3c0d8b15bb33ddb1df8f05cb24c Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Wed, 20 Nov 2024 12:55:37 +0100
Subject: [PATCH 188/306] Revert "Set referenceVersion to 3.6.2-RC1"

This reverts commit 8a0824550b5c39ca2cf8c06ef518f3f12e81ec97.
---
 project/Build.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project/Build.scala b/project/Build.scala
index b4673405bec9..f5593144a631 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -97,7 +97,7 @@ object Build {
    *  - In release branch it should be the last stable release
    *  3.6.0-RC1 was released as 3.6.0 - it's having and experimental TASTy version
    */
-  val referenceVersion = "3.6.2-RC1"
+  val referenceVersion = "3.6.0"
 
   /** Version of the Scala compiler targeted in the current release cycle
    *  Contains a version without RC/SNAPSHOT/NIGHTLY specific suffixes

From cf66d1840e1fcbc9a59e627ac970d866df29036e Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Wed, 20 Nov 2024 13:20:22 +0100
Subject: [PATCH 189/306] Fix the test

---
 tests/neg-custom-args/captures/i21868.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/neg-custom-args/captures/i21868.scala b/tests/neg-custom-args/captures/i21868.scala
index 349750a2ee4b..929e770a21c6 100644
--- a/tests/neg-custom-args/captures/i21868.scala
+++ b/tests/neg-custom-args/captures/i21868.scala
@@ -1,4 +1,4 @@
-import caps.
+import caps.*
 
 trait AbstractWrong:
     type C <: CapSet

From 2be2a60e88fdf4d2ef579a3e624b0e3e04ef77b8 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Thu, 21 Nov 2024 13:08:55 +0100
Subject: [PATCH 190/306] Cancel stale CI executions when CI is re-triggered in
 the same branch/PR (#21974)

Cancels any in-progress runs within the same group identified by
workflow name and GH reference (branch or tag)
For example it would:
- terminate previous PR CI execution after pushing more changes to the
same PR branch

Co-authored-by: Tomasz Godzik <tgodzik@users.noreply.github.com>
---
 .github/workflows/ci.yaml | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 303922719b5b..a2006e16c7e8 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -26,6 +26,14 @@ on:
     - cron: '0 3 * * *'  # Every day at 3 AM
   workflow_dispatch:
 
+# Cancels any in-progress runs within the same group identified by workflow name and GH reference (branch or tag) 
+# For example it would:
+# - terminate previous PR CI execution after pushing more changes to the same PR branch
+# - terminate previous on-push CI run after merging new PR to main 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
+
 env:
   DOTTY_CI_RUN: true
   DEVELOCITY_ACCESS_KEY: ${{ secrets.DEVELOCITY_ACCESS_KEY }}

From a163f0c9257e0165f723b016f20e0b30c7b0a342 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oliver=20Bra=C4=8Devac?= <bracevac@users.noreply.github.com>
Date: Thu, 21 Nov 2024 15:17:45 +0100
Subject: [PATCH 191/306] Report illegal capture reference only once

If we do not strip the capture set at this point,
then the type will be transformed twice and
we'll get the same error message twice.
---
 compiler/src/dotty/tools/dotc/cc/Setup.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index cc456567ce8a..7cd12b999618 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -328,7 +328,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
                 CapturingType(parent2, ann.tree.toCaptureSet)
               catch case ex: IllegalCaptureRef =>
                 report.error(em"Illegal capture reference: ${ex.getMessage.nn}", tptToCheck.fold(NoSourcePosition)(_.srcPos))
-                t
+                parent2
             else
               t.derivedAnnotatedType(parent1, ann)
           case throwsAlias(res, exc) =>

From 63dc305126bf57af6328afeb5f43e596decb6fcb Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Thu, 21 Nov 2024 21:10:31 +0100
Subject: [PATCH 192/306] Consider all arguments in Annotations.refersToParamOf

---
 compiler/src/dotty/tools/dotc/core/Annotations.scala | 2 +-
 tests/pos/dependent-annot-type-param.scala           | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/dependent-annot-type-param.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Annotations.scala b/compiler/src/dotty/tools/dotc/core/Annotations.scala
index d6a99b12e3b3..d7f50d4638ab 100644
--- a/compiler/src/dotty/tools/dotc/core/Annotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Annotations.scala
@@ -73,7 +73,7 @@ object Annotations {
 
     /** Does this annotation refer to a parameter of `tl`? */
     def refersToParamOf(tl: TermLambda)(using Context): Boolean =
-      val args = arguments
+      val args = tpd.allArguments(tree)
       if args.isEmpty then false
       else tree.existsSubTree:
         case id: (Ident | This) => id.tpe.stripped match
diff --git a/tests/pos/dependent-annot-type-param.scala b/tests/pos/dependent-annot-type-param.scala
new file mode 100644
index 000000000000..174e9f78fba6
--- /dev/null
+++ b/tests/pos/dependent-annot-type-param.scala
@@ -0,0 +1,5 @@
+class annot[T] extends annotation.Annotation
+class Box[T]()
+def f(x: Int): Int @annot[Box[x.type]] = x
+def test =
+  val foo = f(42)

From cb08b469025d96cbc8b454d588f14c9dd91448d5 Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Thu, 21 Nov 2024 21:11:16 +0100
Subject: [PATCH 193/306] Make sure symbols in annotation trees are fresh
 before pickling

---
 .../tools/dotc/transform/PostTyper.scala      | 34 ++++++++++++++-----
 tests/pos/annot-17939.scala                   |  8 +++++
 tests/pos/annot-19846.scala                   |  9 +++++
 tests/pos/annot-19846b.scala                  |  8 +++++
 tests/pos/annot-i20272a.scala                 | 20 +++++++++++
 5 files changed, 71 insertions(+), 8 deletions(-)
 create mode 100644 tests/pos/annot-17939.scala
 create mode 100644 tests/pos/annot-19846.scala
 create mode 100644 tests/pos/annot-19846b.scala
 create mode 100644 tests/pos/annot-i20272a.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
index 0feee53ca50f..146871ade3fe 100644
--- a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -2,7 +2,7 @@ package dotty.tools
 package dotc
 package transform
 
-import dotty.tools.dotc.ast.{Trees, tpd, untpd, desugar}
+import dotty.tools.dotc.ast.{Trees, tpd, untpd, desugar, TreeTypeMap}
 import scala.collection.mutable
 import core.*
 import dotty.tools.dotc.typer.Checking
@@ -16,7 +16,7 @@ import Symbols.*, NameOps.*
 import ContextFunctionResults.annotateContextResults
 import config.Printers.typr
 import config.Feature
-import util.SrcPos
+import util.{SrcPos, Stats}
 import reporting.*
 import NameKinds.WildcardParamName
 import cc.*
@@ -154,17 +154,39 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
           case _ =>
       case _ =>
 
+    /** Returns a copy of the given tree with all symbols fresh.
+     *
+     *  Used to guarantee that no symbols are shared between trees in different
+     *  annotations.
+     */
+    private def copySymbols(tree: Tree)(using Context) =
+      Stats.trackTime("Annotations copySymbols"):
+        val ttm =
+          new TreeTypeMap:
+            override def withMappedSyms(syms: List[Symbol]) =
+              withMappedSyms(syms, mapSymbols(syms, this, true))
+        ttm(tree)
+
+    /** Transforms the given annotation tree. */
     private def transformAnnot(annot: Tree)(using Context): Tree = {
       val saved = inJavaAnnot
       inJavaAnnot = annot.symbol.is(JavaDefined)
       if (inJavaAnnot) checkValidJavaAnnotation(annot)
-      try transform(annot)
+      try transform(copySymbols(annot))
       finally inJavaAnnot = saved
     }
 
     private def transformAnnot(annot: Annotation)(using Context): Annotation =
       annot.derivedAnnotation(transformAnnot(annot.tree))
 
+    /** Transforms all annotations in the given type. */
+    private def transformAnnots(using Context) =
+      new TypeMap:
+        def apply(tp: Type) = tp match
+          case tp @ AnnotatedType(parent, annot) =>
+            tp.derivedAnnotatedType(mapOver(parent), transformAnnot(annot))
+          case _ => mapOver(tp)
+
     private def processMemberDef(tree: Tree)(using Context): tree.type = {
       val sym = tree.symbol
       Checking.checkValidOperator(sym)
@@ -524,11 +546,7 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
           super.transform(tree)
         case tree: TypeTree =>
           val tpe = if tree.isInferred then CleanupRetains()(tree.tpe) else tree.tpe
-          tree.withType:
-            tpe match
-              case AnnotatedType(parent, annot) =>
-                AnnotatedType(parent, transformAnnot(annot)) // TODO: Also map annotations embedded in type?
-              case _ => tpe
+          tree.withType(transformAnnots(tpe))
         case Typed(Ident(nme.WILDCARD), _) =>
           withMode(Mode.Pattern)(super.transform(tree))
             // The added mode signals that bounds in a pattern need not
diff --git a/tests/pos/annot-17939.scala b/tests/pos/annot-17939.scala
new file mode 100644
index 000000000000..604143183af2
--- /dev/null
+++ b/tests/pos/annot-17939.scala
@@ -0,0 +1,8 @@
+import scala.annotation.Annotation
+class myRefined[T](f: T => Boolean) extends Annotation
+
+class Box[T](val x: T)
+class Box2(val x: Int)
+
+class A(a: String @myRefined((x: Int) => Box(3).x == 3)) // crash
+class A2(a2: String @myRefined((x: Int) => Box2(3).x == 3)) // works
diff --git a/tests/pos/annot-19846.scala b/tests/pos/annot-19846.scala
new file mode 100644
index 000000000000..ff2f8f632eab
--- /dev/null
+++ b/tests/pos/annot-19846.scala
@@ -0,0 +1,9 @@
+package dependentAnnotation
+
+class lambdaAnnot(g: () => Int) extends annotation.StaticAnnotation
+
+def f(x: Int): Int @lambdaAnnot(() => x + 1) = x
+
+@main def main =
+  val y: Int = 5
+  val z = f(y)
diff --git a/tests/pos/annot-19846b.scala b/tests/pos/annot-19846b.scala
new file mode 100644
index 000000000000..09c24a5cf3cf
--- /dev/null
+++ b/tests/pos/annot-19846b.scala
@@ -0,0 +1,8 @@
+class qualified[T](predicate: T => Boolean) extends annotation.StaticAnnotation
+
+class EqualPair(val x: Int, val y: Int @qualified[Int](it => it == x))
+
+@main def main =
+  val p = EqualPair(42, 42)
+  val y = p.y
+  println(42)
diff --git a/tests/pos/annot-i20272a.scala b/tests/pos/annot-i20272a.scala
new file mode 100644
index 000000000000..e04ee1efcd99
--- /dev/null
+++ b/tests/pos/annot-i20272a.scala
@@ -0,0 +1,20 @@
+import language.experimental.captureChecking
+
+ trait Iterable[T] { self: Iterable[T]^ =>
+   def map[U](f: T => U): Iterable[U]^{this, f}
+ }
+
+ object Test {
+   def assertEquals[A, B](a: A, b: B): Boolean = ???
+
+   def foo[T](level: Int, lines: Iterable[T]) =
+     lines.map(x => x)
+
+   def bar(messages: Iterable[String]) =
+     foo(1, messages)
+
+   val it: Iterable[String] = ???
+   val msgs = bar(it)
+
+   assertEquals(msgs, msgs)
+ }

From ca3c7975ac68b0aba1893d82aadd02809bbc5ced Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Fri, 22 Nov 2024 02:34:57 +0100
Subject: [PATCH 194/306] Do not copy symbols in BodyAnnotations

---
 .../dotty/tools/dotc/transform/PostTyper.scala   | 16 ++++++++++------
 tests/pos/annot-body.scala                       | 15 +++++++++++++++
 2 files changed, 25 insertions(+), 6 deletions(-)
 create mode 100644 tests/pos/annot-body.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
index 146871ade3fe..898517806e50 100644
--- a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -168,19 +168,23 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
         ttm(tree)
 
     /** Transforms the given annotation tree. */
-    private def transformAnnot(annot: Tree)(using Context): Tree = {
+    private def transformAnnotTree(annot: Tree)(using Context): Tree = {
       val saved = inJavaAnnot
       inJavaAnnot = annot.symbol.is(JavaDefined)
       if (inJavaAnnot) checkValidJavaAnnotation(annot)
-      try transform(copySymbols(annot))
+      try transform(annot)
       finally inJavaAnnot = saved
     }
 
     private def transformAnnot(annot: Annotation)(using Context): Annotation =
-      annot.derivedAnnotation(transformAnnot(annot.tree))
+      val tree1 =
+        annot match
+          case _: BodyAnnotation => annot.tree
+          case _ => copySymbols(annot.tree)
+      annot.derivedAnnotation(transformAnnotTree(tree1))
 
     /** Transforms all annotations in the given type. */
-    private def transformAnnots(using Context) =
+    private def transformAnnotsIn(using Context) =
       new TypeMap:
         def apply(tp: Type) = tp match
           case tp @ AnnotatedType(parent, annot) =>
@@ -523,7 +527,7 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
           Checking.checkRealizable(tree.tpt.tpe, tree.srcPos, "SAM type")
           super.transform(tree)
         case tree @ Annotated(annotated, annot) =>
-          cpy.Annotated(tree)(transform(annotated), transformAnnot(annot))
+          cpy.Annotated(tree)(transform(annotated), transformAnnotTree(annot))
         case tree: AppliedTypeTree =>
           if (tree.tpt.symbol == defn.andType)
             Checking.checkNonCyclicInherited(tree.tpe, tree.args.tpes, EmptyScope, tree.srcPos)
@@ -546,7 +550,7 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
           super.transform(tree)
         case tree: TypeTree =>
           val tpe = if tree.isInferred then CleanupRetains()(tree.tpe) else tree.tpe
-          tree.withType(transformAnnots(tpe))
+          tree.withType(transformAnnotsIn(tpe))
         case Typed(Ident(nme.WILDCARD), _) =>
           withMode(Mode.Pattern)(super.transform(tree))
             // The added mode signals that bounds in a pattern need not
diff --git a/tests/pos/annot-body.scala b/tests/pos/annot-body.scala
new file mode 100644
index 000000000000..d8f6f79ae674
--- /dev/null
+++ b/tests/pos/annot-body.scala
@@ -0,0 +1,15 @@
+// This test checks that symbols in `BodyAnnotation` are not copied in
+// `transformAnnot` during `PostTyper`.
+
+package json
+
+trait Reads[A] {
+  def reads(a: Any): A
+}
+
+object JsMacroImpl {
+  inline def reads[A]: Reads[A] =
+    new Reads[A] { self =>
+      def reads(a: Any) = ???
+    }
+}

From 8a5a93af0391ceab775a16bd18f6a46d1c5bf88c Mon Sep 17 00:00:00 2001
From: Jan Chyb <jan.chyb.99@gmail.com>
Date: Fri, 22 Nov 2024 13:51:41 +0100
Subject: [PATCH 195/306] Rethrow SuspendExceptions in CodeGen phase

---
 compiler/src/dotty/tools/backend/jvm/CodeGen.scala |  1 +
 tests/pos-macros/i21983/Test.scala                 | 13 +++++++++++++
 tests/pos-macros/i21983/UsesTest.scala             |  3 +++
 tests/pos-macros/i21983/VisitorMacros.scala        | 13 +++++++++++++
 4 files changed, 30 insertions(+)
 create mode 100644 tests/pos-macros/i21983/Test.scala
 create mode 100644 tests/pos-macros/i21983/UsesTest.scala
 create mode 100644 tests/pos-macros/i21983/VisitorMacros.scala

diff --git a/compiler/src/dotty/tools/backend/jvm/CodeGen.scala b/compiler/src/dotty/tools/backend/jvm/CodeGen.scala
index c5b0ec0929b8..d4843cd56639 100644
--- a/compiler/src/dotty/tools/backend/jvm/CodeGen.scala
+++ b/compiler/src/dotty/tools/backend/jvm/CodeGen.scala
@@ -84,6 +84,7 @@ class CodeGen(val int: DottyBackendInterface, val primitives: DottyPrimitives)(
         registerGeneratedClass(mirrorClassNode, isArtifact = true)
       catch
         case ex: InterruptedException => throw ex
+        case ex: CompilationUnit.SuspendException => throw ex
         case ex: Throwable =>
           ex.printStackTrace()
           report.error(s"Error while emitting ${unit.source}\n${ex.getMessage}", NoSourcePosition)
diff --git a/tests/pos-macros/i21983/Test.scala b/tests/pos-macros/i21983/Test.scala
new file mode 100644
index 000000000000..bf008583c7d9
--- /dev/null
+++ b/tests/pos-macros/i21983/Test.scala
@@ -0,0 +1,13 @@
+package example
+
+sealed trait Test
+
+object Test {
+  case object Foo extends Test
+
+  val visitorType = mkVisitorType[Test]
+
+  trait Visitor[A] {
+    type V[a] = visitorType.Out[a]
+  }
+}
diff --git a/tests/pos-macros/i21983/UsesTest.scala b/tests/pos-macros/i21983/UsesTest.scala
new file mode 100644
index 000000000000..803e93c328c9
--- /dev/null
+++ b/tests/pos-macros/i21983/UsesTest.scala
@@ -0,0 +1,3 @@
+package example
+
+val _ = Test.Foo
diff --git a/tests/pos-macros/i21983/VisitorMacros.scala b/tests/pos-macros/i21983/VisitorMacros.scala
new file mode 100644
index 000000000000..5a5cc453c525
--- /dev/null
+++ b/tests/pos-macros/i21983/VisitorMacros.scala
@@ -0,0 +1,13 @@
+package example
+
+import scala.deriving.Mirror
+import scala.quoted.*
+
+private def mkVisitorTypeImpl[T: Type](using q: Quotes): Expr[VisitorType[T]] =
+  '{new VisitorType[T]{}}
+
+transparent inline def mkVisitorType[T]: VisitorType[T] = ${ mkVisitorTypeImpl[T] }
+
+trait VisitorType[T] {
+  type Out[A]
+}

From f5c9eab427b4373e68c76eee52bcc13e1be811d5 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 5 Oct 2024 17:52:19 +0200
Subject: [PATCH 196/306] Recognize double annotated capabilities such as x*?

x*? is x.type @reach @maybe. This was not recognized before.
---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  |  4 ++--
 tests/neg-custom-args/captures/i21646.scala   | 13 ++++++++++++
 tests/neg-custom-args/captures/uses.scala     | 20 +++++++++++++++++++
 3 files changed, 35 insertions(+), 2 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/i21646.scala
 create mode 100644 tests/neg-custom-args/captures/uses.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index a9272b73e605..56f479debf17 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -639,8 +639,8 @@ object CapsOfApply:
 class AnnotatedCapability(annot: Context ?=> ClassSymbol):
   def apply(tp: Type)(using Context) =
     AnnotatedType(tp, Annotation(annot, util.Spans.NoSpan))
-  def unapply(tree: AnnotatedType)(using Context): Option[SingletonCaptureRef] = tree match
-    case AnnotatedType(parent: SingletonCaptureRef, ann) if ann.symbol == annot => Some(parent)
+  def unapply(tree: AnnotatedType)(using Context): Option[CaptureRef] = tree match
+    case AnnotatedType(parent: CaptureRef, ann) if ann.symbol == annot => Some(parent)
     case _ => None
 
 /** An extractor for `ref @annotation.internal.reachCapability`, which is used to express
diff --git a/tests/neg-custom-args/captures/i21646.scala b/tests/neg-custom-args/captures/i21646.scala
new file mode 100644
index 000000000000..42c493a9ea80
--- /dev/null
+++ b/tests/neg-custom-args/captures/i21646.scala
@@ -0,0 +1,13 @@
+import language.experimental.captureChecking
+import caps.Capability
+
+trait File extends Capability
+
+class Resource[T <: Capability](gen: T):
+  def use[U](f: T => U): U =
+    f(gen) // error
+
+@main def run =
+  val myFile: File = ???
+  val r = Resource(myFile) // error
+  ()
diff --git a/tests/neg-custom-args/captures/uses.scala b/tests/neg-custom-args/captures/uses.scala
new file mode 100644
index 000000000000..b872c7b03ec7
--- /dev/null
+++ b/tests/neg-custom-args/captures/uses.scala
@@ -0,0 +1,20 @@
+class C
+def test(x: C^, y: C^) =
+  class D {
+    println(x)
+    def foo() = println(y)
+  }
+  val d = D()
+  val _: D^{y} = d // error, should be ok
+  val _: D = d // error
+
+  val f = () => println(D())
+  val _: () ->{x} Unit = f // ok
+  val _: () -> Unit = f // should be error
+
+  def g = () =>
+    println(x)
+    () => println(y)
+  val _: () ->{x} () ->{y} Unit = g // error, should be ok
+  val _: () -> () -> Unit = g // error
+

From bbafb09fbe30b9ec66d1c078e00cff0b6ed58454 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Fri, 11 Oct 2024 14:13:33 +0200
Subject: [PATCH 197/306] Refactor narrowCaps

---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  | 38 ++++++++-----------
 1 file changed, 16 insertions(+), 22 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index 56f479debf17..12d68bbb5c34 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -468,29 +468,23 @@ extension (tp: Type)
     end CheckContraCaps
 
     object narrowCaps extends TypeMap:
-      /** Has the variance been flipped at this point? */
-      private var isFlipped: Boolean = false
-
       def apply(t: Type) =
-        val saved = isFlipped
-        try
-          if variance <= 0 then isFlipped = true
-          t.dealias match
-            case t1 @ CapturingType(p, cs) if cs.isUniversal && !isFlipped =>
-              t1.derivedCapturingType(apply(p), ref.reach.singletonCaptureSet)
-            case t1 @ FunctionOrMethod(args, res @ Existential(_, _))
-            if args.forall(_.isAlwaysPure) =>
-              // Also map existentials in results to reach capabilities if all
-              // preceding arguments are known to be always pure
-              apply(t1.derivedFunctionOrMethod(args, Existential.toCap(res)))
-            case Existential(_, _) =>
-              t
-            case _ => t match
-              case t @ CapturingType(p, cs) =>
-                t.derivedCapturingType(apply(p), cs) // don't map capture set variables
-              case t =>
-                mapOver(t)
-        finally isFlipped = saved
+        if variance <= 0 then t
+        else t.dealiasKeepAnnots match
+          case t @ CapturingType(p, cs) if cs.isUniversal =>
+            t.derivedCapturingType(apply(p), ref.reach.singletonCaptureSet)
+          case t @ AnnotatedType(parent, ann) =>
+            // Don't map annotations, which includes capture sets
+            t.derivedAnnotatedType(this(parent), ann)
+          case t @ FunctionOrMethod(args, res @ Existential(_, _))
+          if args.forall(_.isAlwaysPure) =>
+            // Also map existentials in results to reach capabilities if all
+            // preceding arguments are known to be always pure
+            apply(t.derivedFunctionOrMethod(args, Existential.toCap(res)))
+          case Existential(_, _) =>
+            t
+          case _ =>
+            mapOver(t)
     end narrowCaps
 
     ref match

From d33c89a9df9c6ed3269a58222afdedfa82f1d39a Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Fri, 11 Oct 2024 15:25:15 +0200
Subject: [PATCH 198/306] Make sure dcs includes cs

Previously, we violated that assumption is we too the deep capture set
of a capture reference wiht singleton type.
---
 compiler/src/dotty/tools/dotc/cc/CaptureOps.scala | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index 12d68bbb5c34..78b3974a6074 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -228,12 +228,12 @@ extension (tp: Type)
    *  in the type, as computed by `CaptureSet.ofTypeDeeply`.
    */
   def deepCaptureSet(using Context): CaptureSet =
-    val dcs = CaptureSet.ofTypeDeeply(tp)
-    if dcs.isAlwaysEmpty then dcs
+    val dcs = CaptureSet.ofTypeDeeply(tp.widen.stripCapturing)
+    if dcs.isAlwaysEmpty then tp.captureSet
     else tp match
       case tp @ ReachCapability(_) => tp.singletonCaptureSet
-      case tp: SingletonCaptureRef => tp.reach.singletonCaptureSet
-      case _ => dcs
+      case tp: SingletonCaptureRef if tp.isTrackableRef => tp.reach.singletonCaptureSet
+      case _ => tp.captureSet ++ dcs
 
   /** A type capturing `ref` */
   def capturing(ref: CaptureRef)(using Context): Type =

From cdd03b71a41c76e71f677235500d4db51b6f1ea7 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 12 Oct 2024 18:31:51 +0200
Subject: [PATCH 199/306] Align deep capture sets with reach capabilities

Count in dcs exactly those locations where a cap gets replaced by a reach capability.
---
 .../src/dotty/tools/dotc/cc/CaptureSet.scala  | 26 ++++++++++++-------
 tests/neg-custom-args/captures/reaches.check  | 10 ++++++-
 tests/neg-custom-args/captures/reaches.scala  |  4 +--
 .../captures/refine-reach-shallow.scala       |  9 ++++---
 .../captures/refine-withFile.scala            |  4 +--
 5 files changed, 35 insertions(+), 18 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
index 81b4287961ba..835e413463bd 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
@@ -1064,7 +1064,7 @@ object CaptureSet:
     case ref: (TermRef | TermParamRef) if ref.isMaxCapability =>
       if ref.isTrackableRef then ref.singletonCaptureSet
       else CaptureSet.universal
-    case ReachCapability(ref1) => deepCaptureSet(ref1.widen)
+    case ReachCapability(ref1) => ref1.widen.deepCaptureSet
       .showing(i"Deep capture set of $ref: ${ref1.widen} = $result", capt)
     case _ => ofType(ref.underlying, followResult = true)
 
@@ -1115,17 +1115,25 @@ object CaptureSet:
 
   /** The deep capture set of a type is the union of all covariant occurrences of
    *  capture sets. Nested existential sets are approximated with `cap`.
+   *  NOTE: The traversal logic needs to be in sync with narrowCaps in CaptureOps, which
+   *  replaces caps with reach capabilties.
    */
   def ofTypeDeeply(tp: Type)(using Context): CaptureSet =
     val collect = new TypeAccumulator[CaptureSet]:
-      def apply(cs: CaptureSet, t: Type) = t.dealias match
-        case t @ CapturingType(p, cs1) =>
-          val cs2 = apply(cs, p)
-          if variance > 0 then cs2 ++ cs1 else cs2
-        case t @ Existential(_, _) =>
-          apply(cs, Existential.toCap(t))
-        case _ =>
-          foldOver(cs, t)
+      def apply(cs: CaptureSet, t: Type) =
+        if variance <= 0 then cs
+        else t.dealias match
+          case t @ CapturingType(p, cs1) =>
+            this(cs, p) ++ cs1
+          case t @ AnnotatedType(parent, ann) =>
+            this(cs, parent)
+          case t @ FunctionOrMethod(args, res @ Existential(_, _))
+          if args.forall(_.isAlwaysPure) =>
+            this(cs, Existential.toCap(res))
+          case t @ Existential(_, _) =>
+            cs
+          case _ =>
+            foldOver(cs, t)
     collect(CaptureSet.empty, tp)
 
   type AssumedContains = immutable.Map[TypeRef, SimpleIdentitySet[CaptureRef]]
diff --git a/tests/neg-custom-args/captures/reaches.check b/tests/neg-custom-args/captures/reaches.check
index f00fea09ed8c..b578934219f9 100644
--- a/tests/neg-custom-args/captures/reaches.check
+++ b/tests/neg-custom-args/captures/reaches.check
@@ -30,7 +30,7 @@
    |    ^^^^^^^^^^^^^^^^^^^
    |    Local reach capability id* leaks into capture scope of method test
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/reaches.scala:62:27 --------------------------------------
-62 |    val f1: File^{id*} = id(f) // error, since now id(f): File^
+62 |    val f1: File^{id*} = id(f) // error, since now id(f): File^ // error
    |                         ^^^^^
    |                         Found:    File^{f}
    |                         Required: File^{id*}
@@ -50,3 +50,11 @@
    |                                             Type argument () -> Unit does not conform to lower bound () => Unit
    |
    | longer explanation available when compiling with `-explain`
+-- Error: tests/neg-custom-args/captures/reaches.scala:61:31 -----------------------------------------------------------
+61 |  val leaked = usingFile[File^{id*}]: f => // error
+   |                               ^^^
+   |                               id* cannot be tracked since its capture set is empty
+-- Error: tests/neg-custom-args/captures/reaches.scala:62:18 -----------------------------------------------------------
+62 |    val f1: File^{id*} = id(f) // error, since now id(f): File^ // error
+   |                  ^^^
+   |                  id* cannot be tracked since its capture set is empty
diff --git a/tests/neg-custom-args/captures/reaches.scala b/tests/neg-custom-args/captures/reaches.scala
index c33ba80a668b..4db8d0df74d8 100644
--- a/tests/neg-custom-args/captures/reaches.scala
+++ b/tests/neg-custom-args/captures/reaches.scala
@@ -58,8 +58,8 @@ def attack2 =
   val id: File^ -> File^ = x => x
     // val id: File^ -> EX C.File^C
 
-  val leaked = usingFile[File^{id*}]: f =>
-    val f1: File^{id*} = id(f) // error, since now id(f): File^
+  val leaked = usingFile[File^{id*}]: f => // error
+    val f1: File^{id*} = id(f) // error, since now id(f): File^ // error
     f1
 
 class List[+A]:
diff --git a/tests/neg-custom-args/captures/refine-reach-shallow.scala b/tests/neg-custom-args/captures/refine-reach-shallow.scala
index 525d33fdb7c5..f78c99f919af 100644
--- a/tests/neg-custom-args/captures/refine-reach-shallow.scala
+++ b/tests/neg-custom-args/captures/refine-reach-shallow.scala
@@ -5,14 +5,15 @@ def test1(): Unit =
   val g: IO^ => IO^{f*} = f  // error
 def test2(): Unit =
   val f: [R] -> (IO^ => R) -> R = ???
-  val g: [R] -> (IO^{f*} => R) -> R = f  // error
+  val ff = f
+  val g: [R] -> (IO^{f*} => R) -> R = f  // error // error
 def test3(): Unit =
   val f: [R] -> (IO^ -> R) -> R = ???
-  val g: [R] -> (IO^{f*} -> R) -> R = f  // error
+  val g: [R] -> (IO^{f*} -> R) -> R = f  // error // error
 def test4(): Unit =
   val xs: List[IO^] = ???
   val ys: List[IO^{xs*}] = xs  // ok
 def test5(): Unit =
   val f: [R] -> (IO^ -> R) -> IO^ = ???
-  val g: [R] -> (IO^ -> R) -> IO^{f*} = f  // error
-  val h: [R] -> (IO^{f*} -> R) -> IO^ = f  // error
+  val g: [R] -> (IO^ -> R) -> IO^{f*} = f  // error // error
+  val h: [R] -> (IO^{f*} -> R) -> IO^ = f  // error // error
diff --git a/tests/neg-custom-args/captures/refine-withFile.scala b/tests/neg-custom-args/captures/refine-withFile.scala
index 823b62711d05..e7958ab66fc8 100644
--- a/tests/neg-custom-args/captures/refine-withFile.scala
+++ b/tests/neg-custom-args/captures/refine-withFile.scala
@@ -4,5 +4,5 @@ trait File
 val useFile: [R] -> (path: String) -> (op: File^ -> R) -> R = ???
 def main(): Unit =
   val f: [R] -> (path: String) -> (op: File^ -> R) -> R = useFile
-  val g: [R] -> (path: String) -> (op: File^{f*} -> R) -> R = f  // error
-  val leaked = g[File^{f*}]("test")(f => f)  // boom
+  val g: [R] -> (path: String) -> (op: File^{f*} -> R) -> R = f  // error // error
+  val leaked = g[File^{f*}]("test")(f => f)  // error

From 822550d035464912cc71b5ac5c3cbd0537f6b0fb Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 29 Oct 2024 15:26:25 +0100
Subject: [PATCH 200/306] Refactor handling of applications

Simplify code that handles applications, avoiding adding pieces of mutable state.
---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  |   5 +
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 104 ++++++++----------
 .../dotty/tools/dotc/transform/Recheck.scala  |   6 +-
 3 files changed, 52 insertions(+), 63 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index 78b3974a6074..9d1980037d74 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -273,6 +273,11 @@ extension (tp: Type)
     case _ =>
       tp
 
+  /** The first element of this path type */
+  final def pathRoot(using Context): Type = tp.dealias match
+    case tp1: NamedType if tp1.symbol.owner.isClass => tp1.prefix.pathRoot
+    case _ => tp
+
   /** 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.
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 2a3cd50d0e0c..b82c40a4185c 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -429,49 +429,16 @@ class CheckCaptures extends Recheck, SymTransformer:
     end markFree
 
     /** 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)
-
-    private val prefixCalls = util.EqHashSet[GenericApply]()
-    private val unboxedArgs = util.EqHashSet[Tree]()
-
-    def handleCall(meth: Symbol, call: GenericApply, eval: () => Type)(using Context): Type =
-      if prefixCalls.remove(call) then return eval()
-
-      val unboxedParamNames =
-        meth.rawParamss.flatMap: params =>
-          params.collect:
-            case param if param.hasAnnotation(defn.UnboxAnnot) =>
-              param.name
-        .toSet
-
-      def markUnboxedArgs(call: GenericApply): Unit = call.fun.tpe.widen match
-        case MethodType(pnames) =>
-          for (pname, arg) <- pnames.lazyZip(call.args) do
-            if unboxedParamNames.contains(pname) then
-              unboxedArgs.add(arg)
-        case _ =>
-
-      def markPrefixCalls(tree: Tree): Unit = tree match
-        case tree: GenericApply =>
-          prefixCalls.add(tree)
-          markUnboxedArgs(tree)
-          markPrefixCalls(tree.fun)
-        case _ =>
-
-      markUnboxedArgs(call)
-      markPrefixCalls(call.fun)
-      val res = eval()
-      includeCallCaptures(meth, call.srcPos)
-      res
-    end handleCall
+    def includeCallCaptures(sym: Symbol, resType: Type, pos: SrcPos)(using Context): Unit = resType match
+      case _: MethodOrPoly => // wait until method is fully applied
+      case _ =>
+        if sym.exists && curEnv.isOpen then markFree(capturedVars(sym), pos)
 
     override def recheckIdent(tree: Ident, pt: Type)(using Context): Type =
-      if tree.symbol.is(Method) then
-        if tree.symbol.info.isParameterless then
-          // there won't be an apply; need to include call captures now
-          includeCallCaptures(tree.symbol, tree.srcPos)
-      else if !tree.symbol.isStatic then
+      val sym = tree.symbol
+      if sym.is(Method) then
+        includeCallCaptures(sym, sym.info, tree.srcPos)
+      else if !sym.isStatic then
         //debugShowEnvs()
         def addSelects(ref: TermRef, pt: Type): TermRef = pt match
           case pt: PathSelectionProto if ref.isTracked =>
@@ -479,11 +446,11 @@ class CheckCaptures extends Recheck, SymTransformer:
             // class SerializationProxy in stdlib-cc/../LazyListIterable.scala has an example where this matters.
             addSelects(ref.select(pt.sym).asInstanceOf[TermRef], pt.pt)
           case _ => ref
-        val ref = tree.symbol.termRef
+        val ref = sym.termRef
         val pathRef = addSelects(ref, pt)
         //if pathRef ne ref then
         //  println(i"add selects $ref --> $pathRef")
-        markFree(tree.symbol, if false then ref else pathRef, tree.srcPos)
+        markFree(sym, if false then ref else pathRef, tree.srcPos)
       super.recheckIdent(tree, pt)
 
     override def selectionProto(tree: Select, pt: Type)(using Context): Type =
@@ -541,6 +508,16 @@ class CheckCaptures extends Recheck, SymTransformer:
           selType
     }//.showing(i"recheck sel $tree, $qualType = $result")
 
+    /** Copy all @use annotations on method parameter symbols to the corresponding paramInfo types.
+     */
+    override def prepareFunction(funtpe: MethodType, meth: Symbol)(using Context): MethodType =
+      val paramInfosWithUses = funtpe.paramInfos.zipWithConserve(funtpe.paramNames): (formal, pname) =>
+        val paramOpt = meth.rawParamss.nestedFind(_.name == pname)
+        paramOpt.flatMap(_.getAnnotation(defn.UnboxAnnot)) match
+          case Some(ann) => AnnotatedType(formal, ann)
+          case _ => formal
+      funtpe.derivedLambdaType(paramInfos = paramInfosWithUses)
+
     override def recheckApply(tree: Apply, pt: Type)(using Context): Type =
       val meth = tree.fun.symbol
 
@@ -575,15 +552,19 @@ class CheckCaptures extends Recheck, SymTransformer:
             tp.derivedCapturingType(forceBox(parent), refs)
         mapArgUsing(forceBox)
       else
-        handleCall(meth, tree, () => super.recheckApply(tree, pt))
+        val res = super.recheckApply(tree, pt)
+        includeCallCaptures(meth, res, tree.srcPos)
+        res
     end recheckApply
 
     protected override
     def recheckArg(arg: Tree, formal: Type)(using Context): Type =
       val argType = recheck(arg, formal)
-      if unboxedArgs.contains(arg) then
-        capt.println(i"charging deep capture set of $arg: ${argType} = ${argType.deepCaptureSet}")
-        markFree(argType.deepCaptureSet, arg.srcPos)
+      formal match
+        case AnnotatedType(formal1, ann) if ann.symbol == defn.UnboxAnnot =>
+          capt.println(i"charging deep capture set of $arg: ${argType} = ${argType.deepCaptureSet}")
+          markFree(argType.deepCaptureSet, arg.srcPos)
+        case _ =>
       argType
 
     /** A specialized implementation of the apply rule.
@@ -611,10 +592,10 @@ class CheckCaptures extends Recheck, SymTransformer:
       val appType = Existential.toCap(super.recheckApplication(tree, qualType, funType, argTypes))
       val qualCaptures = qualType.captureSet
       val argCaptures =
-        for (arg, argType) <- tree.args.lazyZip(argTypes) yield
-          if unboxedArgs.remove(arg) // need to ensure the remove happens, that's why argCaptures is computed even if not needed.
-          then argType.deepCaptureSet
-          else argType.captureSet
+        for (argType, formal) <- argTypes.lazyZip(funType.paramInfos) yield
+          formal match
+            case AnnotatedType(_, ann) if ann.symbol == defn.UnboxAnnot => argType.deepCaptureSet
+            case _ => argType.captureSet
       appType match
         case appType @ CapturingType(appType1, refs)
         if qualType.exists
@@ -709,8 +690,10 @@ class CheckCaptures extends Recheck, SymTransformer:
               i"Sealed type variable $pname", "be instantiated to",
               i"This is often caused by a local capability$where\nleaking as part of its result.",
               tree.srcPos)
-      try handleCall(meth, tree, () => Existential.toCap(super.recheckTypeApply(tree, pt)))
-      finally checkContains(tree)
+      val res = Existential.toCap(super.recheckTypeApply(tree, pt))
+      includeCallCaptures(meth, res, tree.srcPos)
+      checkContains(tree)
+      res
     end recheckTypeApply
 
     /** Faced with a tree of form `caps.contansImpl[CS, r.type]`, check that `R` is a tracked
@@ -1161,12 +1144,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         (erefs /: erefs.elems): (erefs, eref) =>
           eref match
             case eref: ThisType if isPureContext(ctx.owner, eref.cls) =>
-
-              def pathRoot(aref: Type): Type = aref match
-                case aref: NamedType if aref.symbol.owner.isClass => pathRoot(aref.prefix)
-                case _ => aref
-
-              def isOuterRef(aref: Type): Boolean = pathRoot(aref) match
+              def isOuterRef(aref: Type): Boolean = aref.pathRoot match
                 case aref: NamedType => eref.cls.isProperlyContainedIn(aref.symbol.owner)
                 case aref: ThisType => eref.cls.isProperlyContainedIn(aref.cls)
                 case _ => false
@@ -1176,7 +1154,7 @@ class CheckCaptures extends Recheck, SymTransformer:
               // Include implicitly added outer references in the capture set of the class of `eref`.
               for outerRef <- outerRefs.elems do
                 if !erefs.elems.contains(outerRef)
-                    && !pathRoot(outerRef).isInstanceOf[ThisType]
+                    && !outerRef.pathRoot.isInstanceOf[ThisType]
                     // we don't need to add outer ThisTypes as these are anyway added as path
                     // prefixes at the use site. And this exemption is required since capture sets
                     // of non-local classes are always empty, so we can't add an outer this to them.
@@ -1333,6 +1311,12 @@ class CheckCaptures extends Recheck, SymTransformer:
 
     /** If actual is a tracked CaptureRef `a` and widened is a capturing type T^C,
      *  improve `T^C` to `T^{a}`, following the VAR rule of CC.
+     *  TODO: We probably should do this also for other top-level occurrences of captures
+     *  E.g.
+     *    class Foo { def a: C^{io}; val def: C^{async} }
+     *    val foo: Foo^{io, async}
+     *  Then
+     *    foo: Foo { def a: C^{foo}; def b: C^{foo} }^{foo}
      */
     private def improveCaptures(widened: Type, actual: Type)(using Context): Type = actual match
       case ref: CaptureRef if ref.isTracked =>
diff --git a/compiler/src/dotty/tools/dotc/transform/Recheck.scala b/compiler/src/dotty/tools/dotc/transform/Recheck.scala
index be1d9d8bee54..b7e4b9b14c92 100644
--- a/compiler/src/dotty/tools/dotc/transform/Recheck.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Recheck.scala
@@ -99,7 +99,7 @@ object Recheck:
    *   - in function and method parameter types
    *   - under annotations
    */
-  def normalizeByName(tp: Type)(using Context): Type = tp.dealias match
+  def normalizeByName(tp: Type)(using Context): Type = tp.dealiasKeepAnnots match
     case tp: ExprType =>
       mapExprType(tp)
     case tp: PolyType =>
@@ -291,7 +291,7 @@ abstract class Recheck extends Phase, SymTransformer:
     protected def instantiate(mt: MethodType, argTypes: List[Type], sym: Symbol)(using Context): Type =
       mt.instantiate(argTypes)
 
-    /** A hook to massage the type of an applied method; currently not overridden */
+    /** A hook to massage the type of an applied method */
     protected def prepareFunction(funtpe: MethodType, meth: Symbol)(using Context): MethodType = funtpe
 
     protected def recheckArg(arg: Tree, formal: Type)(using Context): Type =
@@ -336,7 +336,7 @@ abstract class Recheck extends Phase, SymTransformer:
               assert(formals.isEmpty)
               Nil
           val argTypes = recheckArgs(tree.args, formals, fntpe.paramRefs)
-          recheckApplication(tree, qualType, fntpe1, argTypes)
+          recheckApplication(tree, qualType, fntpe, argTypes)
             //.showing(i"typed app $tree : $fntpe with ${tree.args}%, % : $argTypes%, % = $result")
         case tp =>
           assert(false, i"unexpected type of ${tree.fun}: $tp")

From e7c018b07486259c1406abf434b0718ece652187 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Wed, 30 Oct 2024 10:42:21 +0100
Subject: [PATCH 201/306] Handle reach capabilities correctly in markFree

The correct point to address charging reach capabilities is in markFree itself:
When a reach capability goes out of scope, and that capability is not a parameter,
we need to continue with the underlying capture set.
---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  |  39 +++--
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 134 +++++++++---------
 compiler/src/dotty/tools/dotc/cc/Setup.scala  |   3 +-
 .../src/scala/collection/Iterator.scala       |   3 +-
 .../captures/delayedRunops.check              |  14 ++
 .../captures/delayedRunops.scala              |  28 ++++
 tests/neg-custom-args/captures/i16114.check   |  55 +++++++
 tests/neg-custom-args/captures/i21347.check   |  11 +-
 tests/neg-custom-args/captures/i21347.scala   |   2 +-
 tests/neg-custom-args/captures/i21442.check   |   3 +-
 tests/neg-custom-args/captures/path-use.check |   4 +
 tests/neg-custom-args/captures/path-use.scala |  25 ++++
 tests/neg-custom-args/captures/reaches.check  |  10 +-
 tests/neg-custom-args/captures/real-try.scala |   2 +-
 .../captures/unsound-reach-3.scala            |   4 +-
 .../captures/unsound-reach-4.check            |  10 +-
 .../captures/unsound-reach-4.scala            |   4 +-
 tests/neg-custom-args/captures/uses.check     |  28 ++++
 .../neg-custom-args/captures/wf-reach-1.check |   4 +
 .../neg-custom-args/captures/wf-reach-1.scala |   2 +
 .../captures/widen-reach.check                |   6 +-
 tests/neg/leak-problem.scala                  |  19 ++-
 .../captures/gears-problem.scala}             |   3 +-
 tests/pos-custom-args/captures/path-use.scala |  16 ++-
 24 files changed, 319 insertions(+), 110 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/delayedRunops.check
 create mode 100644 tests/neg-custom-args/captures/delayedRunops.scala
 create mode 100644 tests/neg-custom-args/captures/i16114.check
 create mode 100644 tests/neg-custom-args/captures/path-use.check
 create mode 100644 tests/neg-custom-args/captures/path-use.scala
 create mode 100644 tests/neg-custom-args/captures/uses.check
 create mode 100644 tests/neg-custom-args/captures/wf-reach-1.check
 create mode 100644 tests/neg-custom-args/captures/wf-reach-1.scala
 rename tests/{pos/gears-probem.scala => pos-custom-args/captures/gears-problem.scala} (89%)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index 9d1980037d74..f9c33695e9fe 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -221,19 +221,22 @@ extension (tp: Type)
     case tp: SingletonCaptureRef => tp.captureSetOfInfo
     case _ => CaptureSet.ofType(tp, followResult = false)
 
-  /** The deep capture set of a type.
-   *  For singleton capabilities `x` and reach capabilities `x*`, this is `{x*}`, provided
-   *  the underlying capture set resulting from traversing the type is non-empty.
-   *  For other types this is the union of all covariant capture sets embedded
-   *  in the type, as computed by `CaptureSet.ofTypeDeeply`.
+  /** The deep capture set of a type. This is by default the union of all
+   *  covariant capture sets embedded in the widened type, as computed by
+   *  `CaptureSet.ofTypeDeeply`. If that set is nonempty, and the type is
+   *  a singleton capability `x` or a reach capability `x*`, the deep capture
+   *  set can be narrowed to`{x*}`.
    */
   def deepCaptureSet(using Context): CaptureSet =
     val dcs = CaptureSet.ofTypeDeeply(tp.widen.stripCapturing)
     if dcs.isAlwaysEmpty then tp.captureSet
     else tp match
-      case tp @ ReachCapability(_) => tp.singletonCaptureSet
-      case tp: SingletonCaptureRef if tp.isTrackableRef => tp.reach.singletonCaptureSet
-      case _ => tp.captureSet ++ dcs
+      case tp @ ReachCapability(_) =>
+        tp.singletonCaptureSet
+      case tp: SingletonCaptureRef if tp.isTrackableRef =>
+        tp.reach.singletonCaptureSet
+      case _ =>
+        tp.captureSet ++ dcs
 
   /** A type capturing `ref` */
   def capturing(ref: CaptureRef)(using Context): Type =
@@ -274,10 +277,28 @@ extension (tp: Type)
       tp
 
   /** The first element of this path type */
-  final def pathRoot(using Context): Type = tp.dealias match
+  final def pathRoot(using Context): Type = tp.dealiasKeepAnnots match
     case tp1: NamedType if tp1.symbol.owner.isClass => tp1.prefix.pathRoot
+    case ReachCapability(tp1) => tp1.pathRoot
     case _ => tp
 
+  /** If this part starts with `C.this`, the class `C`.
+   *  Otherwise, if it starts with a reference `r`, `r`'s owner.
+   *  Otherwise NoSymbol.
+   */
+  final def pathOwner(using Context): Symbol = pathRoot match
+    case tp1: NamedType => tp1.symbol.owner
+    case tp1: ThisType => tp1.cls
+    case _ => NoSymbol
+
+  final def isParamPath(using Context): Boolean = tp.dealias match
+    case tp1: NamedType =>
+      tp1.prefix match
+        case _: ThisType | NoPrefix =>
+          tp1.symbol.is(Param) || tp1.symbol.is(ParamAccessor)
+        case prefix => prefix.isParamPath
+    case _ => false
+
   /** 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.
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index b82c40a4185c..788da0dbcc57 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -333,20 +333,22 @@ class CheckCaptures extends Recheck, SymTransformer:
         then CaptureSet.Var(sym.owner, level = sym.ccLevel)
         else CaptureSet.empty)
 
-    /** For all nested environments up to `limit` or a closed environment perform `op`,
-     *  but skip environmenrts directly enclosing environments of kind ClosureResult.
+    /** The next environment enclosing `env` that needs to be charged
+     *  with free references.
+     *  Skips environments directly enclosing environments of kind ClosureResult.
+     *  @param included Whether an environment is included in the range of
+     *                  environments to charge. Once `included` is false, no
+     *                  more environments need to be charged.
      */
-    def forallOuterEnvsUpTo(limit: Symbol)(op: Env => Unit)(using Context): Unit =
-      def recur(env: Env, skip: Boolean): Unit =
-        if env.isOpen && env.owner != limit then
-          if !skip then op(env)
-          if !env.isOutermost then
-            var nextEnv = env.outer
-            if env.owner.isConstructor then
-              if nextEnv.owner != limit && !nextEnv.isOutermost then
-                nextEnv = nextEnv.outer
-            recur(nextEnv, skip = env.kind == EnvKind.ClosureResult)
-      recur(curEnv, skip = false)
+    def nextEnvToCharge(env: Env, included: Env => Boolean)(using Context): Env =
+      var nextEnv = env.outer
+      if env.owner.isConstructor then
+        if included(nextEnv) then nextEnv = nextEnv.outer
+      if env.kind == EnvKind.ClosureResult then
+        // skip this one
+        nextEnvToCharge(nextEnv, included)
+      else
+        nextEnv
 
     /** A description where this environment comes from */
     private def provenance(env: Env)(using Context): String =
@@ -360,7 +362,6 @@ class CheckCaptures extends Recheck, SymTransformer:
       else
         i"\nof the enclosing ${owner.showLocated}"
 
-
     /** Include `sym` in the capture sets of all enclosing environments nested in the
      *  the environment in which `sym` is defined.
      */
@@ -369,9 +370,12 @@ class CheckCaptures extends Recheck, SymTransformer:
 
     def markFree(sym: Symbol, ref: TermRef, pos: SrcPos)(using Context): Unit =
       if sym.exists && 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, provenance(env))
+        def recur(env: Env): Unit =
+          if env.isOpen && env.owner != sym.enclosure then
+            capt.println(i"Mark $sym with cs ${ref.captureSet} free in ${env.owner}")
+            checkElem(ref, env.captured, pos, provenance(env))
+            recur(nextEnvToCharge(env, _.owner != sym.enclosure))
+        recur(curEnv)
 
     /** 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
@@ -386,46 +390,53 @@ class CheckCaptures extends Recheck, SymTransformer:
         else
           !sym.isContainedIn(env.owner)
 
-      def checkSubsetEnv(cs: CaptureSet, env: Env)(using Context): Unit =
-        // Only captured references that are visible from the environment
-        // should be included.
-        val included = cs.filter: c =>
-          c.stripReach match
-            case ref: NamedType =>
-              val refSym = ref.symbol
-              val refOwner = refSym.owner
-              val isVisible = isVisibleFromEnv(refOwner, env)
-              if isVisible && !ref.isRootCapability then
-                ref match
-                  case ref: TermRef if ref.prefix `ne` NoPrefix =>
-                    // If c is a path of a class defined outside the environment,
-                    // we check the capture set of its info.
-                    checkSubsetEnv(ref.captureSetOfInfo, env)
-                  case _ =>
-              if !isVisible
-                  && (c.isReach || ref.isType)
-                  && (!ccConfig.useSealed || refSym.is(Param))
-                  && refOwner == env.owner
-              then
-                if refSym.hasAnnotation(defn.UnboxAnnot) then
-                  capt.println(i"exempt: $ref in $refOwner")
-                else
-                  // Reach capabilities that go out of scope have to be approximated
-                  // by their underlying capture set, which cannot be universal.
-                  // Reach capabilities of @unboxed parameters are exempted.
-                  val cs = CaptureSet.ofInfo(c)
-                  cs.disallowRootCapability: () =>
-                    report.error(em"Local reach capability $c leaks into capture scope of ${env.ownerString}", pos)
-                  checkSubset(cs, env.captured, pos, provenance(env))
-              isVisible
-            case ref: ThisType => isVisibleFromEnv(ref.cls, env)
-            case _ => false
-        checkSubset(included, env.captured, pos, provenance(env))
-        capt.println(i"Include call or box capture $included from $cs in ${env.owner} --> ${env.captured}")
-
-      if !cs.isAlwaysEmpty then
-        forallOuterEnvsUpTo(ctx.owner.topLevelClass): env =>
-          checkSubsetEnv(cs, env)
+      def checkUseDeclared(c: CaptureRef, env: Env) =
+        c.pathRoot match
+          case ref: NamedType if !ref.symbol.hasAnnotation(defn.UnboxAnnot) =>
+            val what = if ref.isType then "Capture set parameter" else "Local reach capability"
+            report.error(
+              em"""$what $c leaks into capture scope of ${env.ownerString}.
+                  |To allow this, the ${ref.symbol} should be declared with a @use annotation""", pos)
+          case _ =>
+
+      def recur(cs: CaptureSet, env: Env)(using Context): Unit =
+        if env.isOpen && !env.owner.isStaticOwner && !cs.isAlwaysEmpty then
+          // Only captured references that are visible from the environment
+          // should be included.
+          val included = cs.filter: c =>
+            val isVisible = c.pathRoot match
+              case ref: NamedType => isVisibleFromEnv(ref.symbol.owner, env)
+              case ref: ThisType => isVisibleFromEnv(ref.cls, env)
+              case ref =>
+                false
+            if !isVisible then
+              c match
+                case ReachCapability(c1) =>
+                  if c1.isParamPath then
+                    checkUseDeclared(c, env)
+                  else
+                    // When a reach capabilty x* where `x` is not a parameter goes out
+                    // of scope, we need to continue with `x`'s underlying deep capture set.
+                    // It is an error if that set contains cap.
+                    // The same is not an issue for normal capabilities since in a local
+                    // definition `val x = e`, the capabilities of `e` have already been charged.
+                    // Note: It's not true that the underlying capture set of a reach capability
+                    // is always cap. Reach capabilities over paths depend on the prefix, which
+                    // might turn a cap into something else.
+                    // The path-use.scala neg test contains an example.
+                    val underlying = CaptureSet.ofTypeDeeply(c1.widen)
+                    capt.println(i"Widen reach $c to $underlying in ${env.owner}")
+                    underlying.disallowRootCapability: () =>
+                      report.error(em"Local reach capability $c leaks into capture scope of ${env.ownerString}", pos)
+                    recur(underlying, env)
+                case c: TypeRef if c.isParamPath =>
+                  checkUseDeclared(c, env)
+                case _ =>
+            isVisible
+          checkSubset(included, env.captured, pos, provenance(env))
+          capt.println(i"Include call or box capture $included from $cs in ${env.owner} --> ${env.captured}")
+          recur(included, nextEnvToCharge(env, !_.owner.isStaticOwner))
+      recur(cs, curEnv)
     end markFree
 
     /** Include references captured by the called method in the current environment stack */
@@ -1144,13 +1155,8 @@ class CheckCaptures extends Recheck, SymTransformer:
         (erefs /: erefs.elems): (erefs, eref) =>
           eref match
             case eref: ThisType if isPureContext(ctx.owner, eref.cls) =>
-              def isOuterRef(aref: Type): Boolean = aref.pathRoot match
-                case aref: NamedType => eref.cls.isProperlyContainedIn(aref.symbol.owner)
-                case aref: ThisType => eref.cls.isProperlyContainedIn(aref.cls)
-                case _ => false
-
-              val outerRefs = arefs.filter(isOuterRef)
-
+              val outerRefs = arefs.filter: aref =>
+                eref.cls.isProperlyContainedIn(aref.pathOwner)
               // Include implicitly added outer references in the capture set of the class of `eref`.
               for outerRef <- outerRefs.elems do
                 if !erefs.elems.contains(outerRef)
diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index 7cd12b999618..a64703bf059e 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -763,7 +763,8 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
             report.warning(em"redundant capture: $dom already accounts for $ref", pos)
 
         if ref.captureSetOfInfo.elems.isEmpty && !ref.derivesFrom(defn.Caps_Capability) then
-          report.error(em"$ref cannot be tracked since its capture set is empty", pos)
+          val deepStr = if ref.isReach then " deep" else ""
+          report.error(em"$ref cannot be tracked since its$deepStr capture set is empty", pos)
         check(parent.captureSet, parent)
 
         val others =
diff --git a/scala2-library-cc/src/scala/collection/Iterator.scala b/scala2-library-cc/src/scala/collection/Iterator.scala
index 4d1b0ed4ff95..22632d738199 100644
--- a/scala2-library-cc/src/scala/collection/Iterator.scala
+++ b/scala2-library-cc/src/scala/collection/Iterator.scala
@@ -1159,7 +1159,8 @@ object Iterator extends IterableFactory[Iterator] {
         // If we advanced the current iterator to a ConcatIterator, merge it into this one
         @tailrec def merge(): Unit =
           if (current.isInstanceOf[ConcatIterator[_]]) {
-            val c = current.asInstanceOf[ConcatIterator[A]]
+            val c: ConcatIterator[A] { val from: Iterator[A] }
+               = current.asInstanceOf
             current = c.current.asInstanceOf // !!! CC unsafe op
             currentHasNextChecked = c.currentHasNextChecked
             if (c.tail != null) {
diff --git a/tests/neg-custom-args/captures/delayedRunops.check b/tests/neg-custom-args/captures/delayedRunops.check
new file mode 100644
index 000000000000..68da4672acf5
--- /dev/null
+++ b/tests/neg-custom-args/captures/delayedRunops.check
@@ -0,0 +1,14 @@
+-- Error: tests/neg-custom-args/captures/delayedRunops.scala:16:13 -----------------------------------------------------
+16 |      runOps(ops1)  // error
+   |             ^^^^
+   |             reference ops* is not included in the allowed capture set {}
+   |             of an enclosing function literal with expected type () -> Unit
+-- Error: tests/neg-custom-args/captures/delayedRunops.scala:22:13 -----------------------------------------------------
+22 |      runOps(ops1)  // error
+   |             ^^^^
+   |             Local reach capability ops1* leaks into capture scope of enclosing function
+-- Error: tests/neg-custom-args/captures/delayedRunops.scala:28:13 -----------------------------------------------------
+28 |      runOps(ops1)  // error
+   |             ^^^^
+   |             reference ops* is not included in the allowed capture set {}
+   |             of an enclosing function literal with expected type () -> Unit
diff --git a/tests/neg-custom-args/captures/delayedRunops.scala b/tests/neg-custom-args/captures/delayedRunops.scala
new file mode 100644
index 000000000000..02786bcb836a
--- /dev/null
+++ b/tests/neg-custom-args/captures/delayedRunops.scala
@@ -0,0 +1,28 @@
+import language.experimental.captureChecking
+import caps.unbox
+
+  // ok
+  def runOps(@unbox ops: List[() => Unit]): Unit =
+    ops.foreach(op => op())
+
+  // ok
+  def delayedRunOps(@unbox ops: List[() => Unit]): () ->{ops*} Unit = // @unbox should not be necessary in the future
+    () => runOps(ops)
+
+  // unsound: impure operation pretended pure
+  def delayedRunOps1(ops: List[() => Unit]): () ->{} Unit =
+    () =>
+      val ops1 = ops
+      runOps(ops1)  // error
+
+  // unsound: impure operation pretended pure
+  def delayedRunOps2(ops: List[() => Unit]): () ->{} Unit =
+    () =>
+      val ops1: List[() => Unit] = ops
+      runOps(ops1)  // error
+
+  // unsound: impure operation pretended pure
+  def delayedRunOps3(ops: List[() => Unit]): () ->{} Unit =
+    () =>
+      val ops1: List[() ->{ops*} Unit] = ops
+      runOps(ops1)  // error
diff --git a/tests/neg-custom-args/captures/i16114.check b/tests/neg-custom-args/captures/i16114.check
new file mode 100644
index 000000000000..6d81d8d63747
--- /dev/null
+++ b/tests/neg-custom-args/captures/i16114.check
@@ -0,0 +1,55 @@
+-- Error: tests/neg-custom-args/captures/i16114.scala:18:12 ------------------------------------------------------------
+18 |      expect[Cap^] {  // error
+   |      ^^^^^^^^^^^^
+   |      Sealed type variable T cannot be instantiated to box Cap^ since
+   |      that type captures the root capability `cap`.
+   |      This is often caused by a local capability in an argument of method expect
+   |      leaking as part of its result.
+-- Error: tests/neg-custom-args/captures/i16114.scala:20:8 -------------------------------------------------------------
+20 |        fs  // error (limitation)
+   |        ^^
+   |        (fs : Cap^) cannot be referenced here; it is not included in the allowed capture set {io}
+   |        of an enclosing function literal with expected type Unit ->{io} Unit
+-- Error: tests/neg-custom-args/captures/i16114.scala:24:12 ------------------------------------------------------------
+24 |      expect[Cap^] { // error
+   |      ^^^^^^^^^^^^
+   |      Sealed type variable T cannot be instantiated to box Cap^ since
+   |      that type captures the root capability `cap`.
+   |      This is often caused by a local capability in an argument of method expect
+   |      leaking as part of its result.
+-- Error: tests/neg-custom-args/captures/i16114.scala:26:8 -------------------------------------------------------------
+26 |        io  // error (limitation)
+   |        ^^
+   |        (io : Cap^) cannot be referenced here; it is not included in the allowed capture set {fs}
+   |        of an enclosing function literal with expected type Unit ->{fs} Unit
+-- Error: tests/neg-custom-args/captures/i16114.scala:30:12 ------------------------------------------------------------
+30 |      expect[Cap^] {  // error
+   |      ^^^^^^^^^^^^
+   |      Sealed type variable T cannot be instantiated to box Cap^ since
+   |      that type captures the root capability `cap`.
+   |      This is often caused by a local capability in an argument of method expect
+   |      leaking as part of its result.
+-- Error: tests/neg-custom-args/captures/i16114.scala:36:12 ------------------------------------------------------------
+36 |      expect[Cap^](io) // error
+   |      ^^^^^^^^^^^^
+   |      Sealed type variable T cannot be instantiated to box Cap^ since
+   |      that type captures the root capability `cap`.
+   |      This is often caused by a local capability in an argument of method expect
+   |      leaking as part of its result.
+-- Error: tests/neg-custom-args/captures/i16114.scala:39:12 ------------------------------------------------------------
+39 |      expect[Cap^] { // error
+   |      ^^^^^^^^^^^^
+   |      Sealed type variable T cannot be instantiated to box Cap^ since
+   |      that type captures the root capability `cap`.
+   |      This is often caused by a local capability in an argument of method expect
+   |      leaking as part of its result.
+-- Error: tests/neg-custom-args/captures/i16114.scala:40:8 -------------------------------------------------------------
+40 |        io.use()    // error
+   |        ^^
+   |        (io : Cap^) cannot be referenced here; it is not included in the allowed capture set {}
+   |        of an enclosing function literal with expected type Unit -> Unit
+-- Error: tests/neg-custom-args/captures/i16114.scala:41:8 -------------------------------------------------------------
+41 |        io          // error
+   |        ^^
+   |        (io : Cap^) cannot be referenced here; it is not included in the allowed capture set {}
+   |        of an enclosing function literal with expected type Unit -> Unit
diff --git a/tests/neg-custom-args/captures/i21347.check b/tests/neg-custom-args/captures/i21347.check
index c680a54d3efc..e1845d9778d5 100644
--- a/tests/neg-custom-args/captures/i21347.check
+++ b/tests/neg-custom-args/captures/i21347.check
@@ -1,15 +1,12 @@
 -- Error: tests/neg-custom-args/captures/i21347.scala:4:15 -------------------------------------------------------------
 4 |  ops.foreach: op => // error
   |               ^
-  |               Local reach capability C leaks into capture scope of method runOps
+  |               Capture set parameter C leaks into capture scope of method runOps.
+  |               To allow this, the type C should be declared with a @use annotation
 5 |    op()
--- Error: tests/neg-custom-args/captures/i21347.scala:8:14 -------------------------------------------------------------
-8 |  () => runOps(f :: Nil) // error
-  |        ^^^^^^^^^^^^^^^^
-  |        reference (caps.cap : caps.Capability) is not included in the allowed capture set {}
-  |        of an enclosing function literal with expected type () -> Unit
 -- Error: tests/neg-custom-args/captures/i21347.scala:11:15 ------------------------------------------------------------
 11 |  ops.foreach: op => // error
    |               ^
-   |               Local reach capability ops* leaks into capture scope of method runOpsAlt
+   |               Local reach capability ops* leaks into capture scope of method runOpsAlt.
+   |               To allow this, the parameter ops should be declared with a @use annotation
 12 |    op()
diff --git a/tests/neg-custom-args/captures/i21347.scala b/tests/neg-custom-args/captures/i21347.scala
index 41887be6a78a..54fe859caedd 100644
--- a/tests/neg-custom-args/captures/i21347.scala
+++ b/tests/neg-custom-args/captures/i21347.scala
@@ -5,7 +5,7 @@ def runOps[C^](ops: List[() ->{C^} Unit]): Unit =
     op()
 
 def boom(f: () => Unit): () -> Unit =
-  () => runOps(f :: Nil) // error
+  () => runOps(f :: Nil) // now ok
 
 def runOpsAlt(ops: List[() => Unit]): Unit =
   ops.foreach: op => // error
diff --git a/tests/neg-custom-args/captures/i21442.check b/tests/neg-custom-args/captures/i21442.check
index a3bbf65c5988..30becfea0215 100644
--- a/tests/neg-custom-args/captures/i21442.check
+++ b/tests/neg-custom-args/captures/i21442.check
@@ -1,7 +1,8 @@
 -- Error: tests/neg-custom-args/captures/i21442.scala:9:13 -------------------------------------------------------------
 9 |  val io = x.unbox // error: local reach capability {x*} leaks
   |           ^^^^^^^
-  |           Local reach capability x* leaks into capture scope of method foo
+  |           Local reach capability x* leaks into capture scope of method foo.
+  |           To allow this, the parameter x should be declared with a @use annotation
 -- Error: tests/neg-custom-args/captures/i21442.scala:17:14 ------------------------------------------------------------
 17 |  val io = x1.unbox // error
    |           ^^^^^^^^
diff --git a/tests/neg-custom-args/captures/path-use.check b/tests/neg-custom-args/captures/path-use.check
new file mode 100644
index 000000000000..e09ee232dd17
--- /dev/null
+++ b/tests/neg-custom-args/captures/path-use.check
@@ -0,0 +1,4 @@
+-- Error: tests/neg-custom-args/captures/path-use.scala:18:32 ----------------------------------------------------------
+18 |  val g = () => println(c.procs.head) // error, local reach capability c.procs* leaks
+   |                        ^^^^^^^^^^^^
+   |                        Local reach capability c.procs* leaks into capture scope of method test
diff --git a/tests/neg-custom-args/captures/path-use.scala b/tests/neg-custom-args/captures/path-use.scala
new file mode 100644
index 000000000000..31feb4c0adf4
--- /dev/null
+++ b/tests/neg-custom-args/captures/path-use.scala
@@ -0,0 +1,25 @@
+import language.experimental.namedTuples
+
+class IO
+
+class C(val f: IO^):
+  val procs: List[Proc] = ???
+
+type Proc = () => Unit
+
+def test(io: IO^) =
+  val c = C(io)
+  val f = () => println(c.f)
+  val _: () ->{c.f} Unit = f
+
+  val x = c.procs
+  val _: List[() ->{c.procs*} Unit] = x
+
+  val g = () => println(c.procs.head) // error, local reach capability c.procs* leaks
+  val _: () ->{c.procs*} Unit = g
+
+  val cc: C { val f: IO^{io}; val procs: List[() ->{io} Unit] }^{io} =
+    ???
+
+  val gg = () => println(cc.procs.head) // OK, since cc.procs* has {io} as underlying capture set
+  val _: () ->{io} Unit = gg
diff --git a/tests/neg-custom-args/captures/reaches.check b/tests/neg-custom-args/captures/reaches.check
index b578934219f9..0121f0cf7a55 100644
--- a/tests/neg-custom-args/captures/reaches.check
+++ b/tests/neg-custom-args/captures/reaches.check
@@ -39,11 +39,13 @@
 -- Error: tests/neg-custom-args/captures/reaches.scala:79:10 -----------------------------------------------------------
 79 |  ps.map((x, y) => compose1(x, y)) // error // error
    |          ^
-   |          Local reach capability ps* leaks into capture scope of method mapCompose
+   |          Local reach capability ps* leaks into capture scope of method mapCompose.
+   |          To allow this, the parameter ps should be declared with a @use annotation
 -- Error: tests/neg-custom-args/captures/reaches.scala:79:13 -----------------------------------------------------------
 79 |  ps.map((x, y) => compose1(x, y)) // error // error
    |             ^
-   |             Local reach capability ps* leaks into capture scope of method mapCompose
+   |             Local reach capability ps* leaks into capture scope of method mapCompose.
+   |             To allow this, the parameter ps should be declared with a @use annotation
 -- [E057] Type Mismatch Error: tests/neg-custom-args/captures/reaches.scala:53:51 --------------------------------------
 53 |  val id: Id[Proc, Proc] = new Id[Proc, () -> Unit] // error
    |                                                   ^
@@ -53,8 +55,8 @@
 -- Error: tests/neg-custom-args/captures/reaches.scala:61:31 -----------------------------------------------------------
 61 |  val leaked = usingFile[File^{id*}]: f => // error
    |                               ^^^
-   |                               id* cannot be tracked since its capture set is empty
+   |                               id* cannot be tracked since its deep capture set is empty
 -- Error: tests/neg-custom-args/captures/reaches.scala:62:18 -----------------------------------------------------------
 62 |    val f1: File^{id*} = id(f) // error, since now id(f): File^ // error
    |                  ^^^
-   |                  id* cannot be tracked since its capture set is empty
+   |                  id* cannot be tracked since its deep capture set is empty
diff --git a/tests/neg-custom-args/captures/real-try.scala b/tests/neg-custom-args/captures/real-try.scala
index 51f1a0fdea5a..8e60d4fe7326 100644
--- a/tests/neg-custom-args/captures/real-try.scala
+++ b/tests/neg-custom-args/captures/real-try.scala
@@ -35,4 +35,4 @@ def test(): Unit =
     case _: Ex1 => ???
     case _: Ex2 => ???
 
-  b.x
+  b
diff --git a/tests/neg-custom-args/captures/unsound-reach-3.scala b/tests/neg-custom-args/captures/unsound-reach-3.scala
index 0063216e957e..985beb7ae55d 100644
--- a/tests/neg-custom-args/captures/unsound-reach-3.scala
+++ b/tests/neg-custom-args/captures/unsound-reach-3.scala
@@ -16,8 +16,8 @@ def bad(): Unit =
   val boom: Foo[File^{backdoor*}] = backdoor
 
   var escaped: File^{backdoor*} = null
-  withFile("hello.txt"): f => // error
-    escaped = boom.use(f)
+  withFile("hello.txt"): f =>
+    escaped = boom.use(f) // error
       // boom.use: (x: File^) -> File^{backdoor*}, it is a selection so reach capabilities are allowed
       // f: File^, so there is no reach capabilities
 
diff --git a/tests/neg-custom-args/captures/unsound-reach-4.check b/tests/neg-custom-args/captures/unsound-reach-4.check
index d359b298555e..ed8e29cdf511 100644
--- a/tests/neg-custom-args/captures/unsound-reach-4.check
+++ b/tests/neg-custom-args/captures/unsound-reach-4.check
@@ -1,6 +1,4 @@
--- Error: tests/neg-custom-args/captures/unsound-reach-4.scala:21:25 ---------------------------------------------------
-21 |  withFile("hello.txt"): f =>  // error
-   |                         ^
-   |                         Reach capability backdoor* and universal capability cap cannot both
-   |                         appear in the type (f: File^) ->{backdoor*} Unit of this expression
-22 |    escaped = boom.use(f)
+-- Error: tests/neg-custom-args/captures/unsound-reach-4.scala:22:22 ---------------------------------------------------
+22 |    escaped = boom.use(f)  // error
+   |              ^^^^^^^^^^^
+   |              Local reach capability backdoor* leaks into capture scope of method bad
diff --git a/tests/neg-custom-args/captures/unsound-reach-4.scala b/tests/neg-custom-args/captures/unsound-reach-4.scala
index bc66085614f2..14050b4afff2 100644
--- a/tests/neg-custom-args/captures/unsound-reach-4.scala
+++ b/tests/neg-custom-args/captures/unsound-reach-4.scala
@@ -18,5 +18,5 @@ def bad(): Unit =
   val boom: Foo[File^{backdoor*}] = backdoor
 
   var escaped: File^{backdoor*} = null
-  withFile("hello.txt"): f =>  // error
-    escaped = boom.use(f)
+  withFile("hello.txt"): f =>
+    escaped = boom.use(f)  // error
diff --git a/tests/neg-custom-args/captures/uses.check b/tests/neg-custom-args/captures/uses.check
new file mode 100644
index 000000000000..de583d75db06
--- /dev/null
+++ b/tests/neg-custom-args/captures/uses.check
@@ -0,0 +1,28 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/uses.scala:8:17 ------------------------------------------
+8 |  val _: D^{y} = d // error, should be ok
+  |                 ^
+  |                 Found:    (d : D^{x, y})
+  |                 Required: D^{y}
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/uses.scala:9:13 ------------------------------------------
+9 |  val _: D = d // error
+  |             ^
+  |             Found:    (d : D^{x, y})
+  |             Required: D
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/uses.scala:18:34 -----------------------------------------
+18 |  val _: () ->{x} () ->{y} Unit = g // error, should be ok
+   |                                  ^
+   |                                  Found:    () ->{x, y} (ex$7: caps.Exists) -> () ->{y} Unit
+   |                                  Required: () ->{x} () ->{y} Unit
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/uses.scala:19:28 -----------------------------------------
+19 |  val _: () -> () -> Unit = g // error
+   |                            ^
+   |                            Found:    () ->{x, y} (ex$7: caps.Exists) -> () ->{y} Unit
+   |                            Required: () -> () -> Unit
+   |
+   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/wf-reach-1.check b/tests/neg-custom-args/captures/wf-reach-1.check
new file mode 100644
index 000000000000..6a3ac9771a11
--- /dev/null
+++ b/tests/neg-custom-args/captures/wf-reach-1.check
@@ -0,0 +1,4 @@
+-- Error: tests/neg-custom-args/captures/wf-reach-1.scala:2:17 ---------------------------------------------------------
+2 |  val y: Object^{x*} = ??? // error
+  |                 ^^
+  |                 x* cannot be tracked since its deep capture set is empty
diff --git a/tests/neg-custom-args/captures/wf-reach-1.scala b/tests/neg-custom-args/captures/wf-reach-1.scala
new file mode 100644
index 000000000000..c8901c7ae4a8
--- /dev/null
+++ b/tests/neg-custom-args/captures/wf-reach-1.scala
@@ -0,0 +1,2 @@
+def test(x: List[() -> Unit]) =
+  val y: Object^{x*} = ??? // error
diff --git a/tests/neg-custom-args/captures/widen-reach.check b/tests/neg-custom-args/captures/widen-reach.check
index 06d21ff445d8..abc065a1e2bc 100644
--- a/tests/neg-custom-args/captures/widen-reach.check
+++ b/tests/neg-custom-args/captures/widen-reach.check
@@ -1,11 +1,13 @@
 -- Error: tests/neg-custom-args/captures/widen-reach.scala:13:26 -------------------------------------------------------
 13 |  val y2: IO^ -> IO^ = y1.foo      // error
    |                       ^^^^^^
-   |                       Local reach capability x* leaks into capture scope of method test
+   |                       Local reach capability x* leaks into capture scope of method test.
+   |                       To allow this, the parameter x should be declared with a @use annotation
 -- Error: tests/neg-custom-args/captures/widen-reach.scala:14:30 -------------------------------------------------------
 14 |  val y3: IO^ -> IO^{x*} = y1.foo  // error
    |                           ^^^^^^
-   |                           Local reach capability x* leaks into capture scope of method test
+   |                           Local reach capability x* leaks into capture scope of method test.
+   |                           To allow this, the parameter x should be declared with a @use annotation
 -- [E164] Declaration Error: tests/neg-custom-args/captures/widen-reach.scala:9:6 --------------------------------------
 9 |  val foo: IO^ -> IO^ = x => x // error
   |      ^
diff --git a/tests/neg/leak-problem.scala b/tests/neg/leak-problem.scala
index 354d54d86707..dea2496d6c77 100644
--- a/tests/neg/leak-problem.scala
+++ b/tests/neg/leak-problem.scala
@@ -1,4 +1,5 @@
 import language.experimental.captureChecking
+import caps.unbox
 
 // Some capabilities that should be used locally
 trait Async:
@@ -16,12 +17,28 @@ def useBoxedAsync(x: Box[Async^]): Unit =
 def useBoxedAsync1(x: Box[Async^]): Unit = x.get.read() // error
 
 def test(): Unit =
+  def useBoxedAsync(@unbox x: Box[Async^]): Unit =
+    val t0 = x
+    val t1 = t0.get
+    t1.read()
+
+  def useBoxedAsync1(@unbox x: Box[Async^]): Unit = x.get.read()
+
+  val xs: Box[Async^] = ???
+  val xsLambda = () => useBoxedAsync(xs) // error
+  val _: () ->{xs*} Unit = xsLambda
+  val _: () -> Unit = xsLambda // error
+
   val useBoxedAsync2 = (x: Box[Async^]) =>
     val t0 = x
     val t1 = x.get // error
     t1.read()
 
-  val f: Box[Async^] => Unit = (x:  Box[Async^]) => useBoxedAsync(x)
+  val xsLambda2 = () => useBoxedAsync2(xs)
+  val _: () ->{xs*} Unit = xsLambda2
+  val _: () -> Unit = xsLambda2
+
+  val f: Box[Async^] => Unit = (x:  Box[Async^]) => useBoxedAsync(x) // error
 
   def boom(x: Async^): () ->{f} Unit =
     () => f(Box(x))
diff --git a/tests/pos/gears-probem.scala b/tests/pos-custom-args/captures/gears-problem.scala
similarity index 89%
rename from tests/pos/gears-probem.scala
rename to tests/pos-custom-args/captures/gears-problem.scala
index 2e445c985de2..74f108f93e80 100644
--- a/tests/pos/gears-probem.scala
+++ b/tests/pos-custom-args/captures/gears-problem.scala
@@ -1,4 +1,5 @@
 import language.experimental.captureChecking
+import caps.unbox
 
 trait Future[+T]:
   def await: T
@@ -10,7 +11,7 @@ class Collector[T](val futures: Seq[Future[T]^]):
   val results: Channel[Future[T]^{futures*}] = ???
 end Collector
 
-extension [T](fs: Seq[Future[T]^])
+extension [T](@unbox fs: Seq[Future[T]^])
   def awaitAll =
     val collector: Collector[T]{val futures: Seq[Future[T]^{fs*}]}
        = Collector(fs)
diff --git a/tests/pos-custom-args/captures/path-use.scala b/tests/pos-custom-args/captures/path-use.scala
index 5eb2b60fd218..181afc41bcc2 100644
--- a/tests/pos-custom-args/captures/path-use.scala
+++ b/tests/pos-custom-args/captures/path-use.scala
@@ -1,4 +1,5 @@
 import language.experimental.namedTuples
+import caps.unbox
 
 class IO
 
@@ -8,12 +9,13 @@ class C(val f: IO^):
 type Proc = () => Unit
 
 def test(io: IO^) =
-  val c = C(io)
-  val f = () => println(c.f)
-  val _: () ->{c.f} Unit = f
+  def test1(@unbox c: C { val f: IO^{io}}^{io}) =
+    val f = () => println(c.f)
+    val _: () ->{c.f} Unit = f
 
-  val x = c.procs
-  val _: List[() ->{c.procs*} Unit] = x
+    val x = c.procs
+    val _: List[() ->{c.procs*} Unit] = x
 
-  val g = () => println(c.procs.head)
-  val _: () ->{c.procs*} Unit = g
+    val g = () => println(c.procs.head)
+    val _: () ->{c.procs*} Unit = g
+  test1(C(io))

From fcf40454ff617ec2e06b339d01e8668a9579be7a Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Wed, 30 Oct 2024 12:27:12 +0100
Subject: [PATCH 202/306] Rename @unbox to @use

---
 .../dotty/tools/dotc/cc/CheckCaptures.scala    | 18 +++++++++---------
 .../dotty/tools/dotc/core/Definitions.scala    |  2 +-
 library/src/scala/caps.scala                   |  2 +-
 .../captures/delayedRunops.scala               |  6 +++---
 tests/neg-custom-args/captures/i15749a.scala   |  4 ++--
 tests/neg-custom-args/captures/i21614.scala    |  6 +++---
 .../captures/leak-problem-2.scala              |  2 +-
 tests/neg-custom-args/captures/reaches.scala   |  8 ++++----
 .../captures/spread-problem.scala              |  2 +-
 .../captures/unbox-overrides.check             |  8 ++++----
 .../captures/unbox-overrides.scala             |  8 ++++----
 tests/neg/i20503.scala                         |  4 ++--
 tests/neg/leak-problem-unboxed.scala           |  6 +++---
 tests/neg/leak-problem.scala                   |  6 +++---
 tests/pos-custom-args/captures/Buffer.scala    |  2 +-
 tests/pos-custom-args/captures/dep-reach.scala |  6 +++---
 .../captures/gears-problem.scala               |  4 ++--
 tests/pos-custom-args/captures/path-use.scala  |  5 +++--
 tests/pos-custom-args/captures/reaches.scala   |  4 ++--
 tests/pos/Buffer.scala                         |  2 +-
 tests/pos/cc-poly-source-capability.scala      |  4 ++--
 tests/pos/cc-poly-source.scala                 |  4 ++--
 tests/pos/gears-probem-1.scala                 |  4 ++--
 tests/pos/i18699.scala                         |  4 ++--
 tests/pos/reach-capability.scala               |  4 ++--
 tests/pos/reach-problem.scala                  |  4 ++--
 26 files changed, 65 insertions(+), 64 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 788da0dbcc57..5b4105a0b778 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -392,7 +392,7 @@ class CheckCaptures extends Recheck, SymTransformer:
 
       def checkUseDeclared(c: CaptureRef, env: Env) =
         c.pathRoot match
-          case ref: NamedType if !ref.symbol.hasAnnotation(defn.UnboxAnnot) =>
+          case ref: NamedType if !ref.symbol.hasAnnotation(defn.UseAnnot) =>
             val what = if ref.isType then "Capture set parameter" else "Local reach capability"
             report.error(
               em"""$what $c leaks into capture scope of ${env.ownerString}.
@@ -524,7 +524,7 @@ class CheckCaptures extends Recheck, SymTransformer:
     override def prepareFunction(funtpe: MethodType, meth: Symbol)(using Context): MethodType =
       val paramInfosWithUses = funtpe.paramInfos.zipWithConserve(funtpe.paramNames): (formal, pname) =>
         val paramOpt = meth.rawParamss.nestedFind(_.name == pname)
-        paramOpt.flatMap(_.getAnnotation(defn.UnboxAnnot)) match
+        paramOpt.flatMap(_.getAnnotation(defn.UseAnnot)) match
           case Some(ann) => AnnotatedType(formal, ann)
           case _ => formal
       funtpe.derivedLambdaType(paramInfos = paramInfosWithUses)
@@ -572,7 +572,7 @@ class CheckCaptures extends Recheck, SymTransformer:
     def recheckArg(arg: Tree, formal: Type)(using Context): Type =
       val argType = recheck(arg, formal)
       formal match
-        case AnnotatedType(formal1, ann) if ann.symbol == defn.UnboxAnnot =>
+        case AnnotatedType(formal1, ann) if ann.symbol == defn.UseAnnot =>
           capt.println(i"charging deep capture set of $arg: ${argType} = ${argType.deepCaptureSet}")
           markFree(argType.deepCaptureSet, arg.srcPos)
         case _ =>
@@ -586,13 +586,13 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  ---------------------
      *  E |- f(a): Tr^C
      *
-     *  If the function `f` does not have an `@unboxed` parameter, then
+     *  If the function `f` does not have an `@use` parameter, then
      *  any unboxing it does would be charged to the environment of the function
      *  so they have to appear in Cq. Since any capabilities of the result of the
      *  application must already be present in the application, an upper
      *  approximation of the result capture set is Cq \union Ca, where `Ca`
      *  is the capture set of the argument.
-     *  If the function `f` does have an `@unboxed` parameter, then it could in addition
+     *  If the function `f` does have an `@use` parameter, then it could in addition
      *  unbox reach capabilities over its formal parameter. Therefore, the approximation
      *  would be `Cq \union dcs(Ca)` instead.
      *  If the approximation is known to subcapture the declared result Cr, we pick it for C
@@ -605,7 +605,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       val argCaptures =
         for (argType, formal) <- argTypes.lazyZip(funType.paramInfos) yield
           formal match
-            case AnnotatedType(_, ann) if ann.symbol == defn.UnboxAnnot => argType.deepCaptureSet
+            case AnnotatedType(_, ann) if ann.symbol == defn.UseAnnot => argType.deepCaptureSet
             case _ => argType.captureSet
       appType match
         case appType @ CapturingType(appType1, refs)
@@ -1384,16 +1384,16 @@ class CheckCaptures extends Recheck, SymTransformer:
 
         override def checkInheritedTraitParameters: Boolean = false
 
-        /** Check that overrides don't change the @unbox status of their parameters */
+        /** Check that overrides don't change the @use status of their parameters */
         override def additionalChecks(member: Symbol, other: Symbol)(using Context): Unit =
           for
             (params1, params2) <- member.rawParamss.lazyZip(other.rawParamss)
             (param1, param2) <- params1.lazyZip(params2)
           do
-            if param1.hasAnnotation(defn.UnboxAnnot) != param2.hasAnnotation(defn.UnboxAnnot) then
+            if param1.hasAnnotation(defn.UseAnnot) != param2.hasAnnotation(defn.UseAnnot) then
               report.error(
                 OverrideError(
-                    i"has a parameter ${param1.name} with different @unbox status than the corresponding parameter in the overridden definition",
+                    i"has a parameter ${param1.name} with different @use status than the corresponding parameter in the overridden definition",
                     self, member, other, self.memberInfo(member), self.memberInfo(other)
                   ),
                 if member.owner == clazz then member.srcPos else clazz.srcPos
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 0195a4ddbf34..1e36cb6f22db 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -1057,12 +1057,12 @@ class Definitions {
   @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 UnboxAnnot:  ClassSymbol = requiredClass("scala.caps.unbox")
   @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 UncheckedCapturesAnnot: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedCaptures")
   @tu lazy val UntrackedCapturesAnnot: ClassSymbol = requiredClass("scala.caps.untrackedCaptures")
+  @tu lazy val UseAnnot:  ClassSymbol = requiredClass("scala.caps.use")
   @tu lazy val VolatileAnnot: ClassSymbol = requiredClass("scala.volatile")
   @tu lazy val BeanGetterMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.beanGetter")
   @tu lazy val BeanSetterMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.beanSetter")
diff --git a/library/src/scala/caps.scala b/library/src/scala/caps.scala
index 9911ef920116..6c7610e410c0 100644
--- a/library/src/scala/caps.scala
+++ b/library/src/scala/caps.scala
@@ -55,7 +55,7 @@ import annotation.{experimental, compileTimeOnly, retainsCap}
   /** This should go into annotations. For now it is here, so that we
    *  can experiment with it quickly between minor releases
    */
-  final class unbox extends annotation.StaticAnnotation
+  final class use extends annotation.StaticAnnotation
 
   object unsafe:
 
diff --git a/tests/neg-custom-args/captures/delayedRunops.scala b/tests/neg-custom-args/captures/delayedRunops.scala
index 02786bcb836a..191118fa19c9 100644
--- a/tests/neg-custom-args/captures/delayedRunops.scala
+++ b/tests/neg-custom-args/captures/delayedRunops.scala
@@ -1,12 +1,12 @@
 import language.experimental.captureChecking
-import caps.unbox
+import caps.use
 
   // ok
-  def runOps(@unbox ops: List[() => Unit]): Unit =
+  def runOps(@use ops: List[() => Unit]): Unit =
     ops.foreach(op => op())
 
   // ok
-  def delayedRunOps(@unbox ops: List[() => Unit]): () ->{ops*} Unit = // @unbox should not be necessary in the future
+  def delayedRunOps(@use ops: List[() => Unit]): () ->{ops*} Unit = // @use should not be necessary in the future
     () => runOps(ops)
 
   // unsound: impure operation pretended pure
diff --git a/tests/neg-custom-args/captures/i15749a.scala b/tests/neg-custom-args/captures/i15749a.scala
index 57fca27fae66..d3c1fce13322 100644
--- a/tests/neg-custom-args/captures/i15749a.scala
+++ b/tests/neg-custom-args/captures/i15749a.scala
@@ -1,5 +1,5 @@
 import caps.cap
-import caps.unbox
+import caps.use
 
 class Unit
 object u extends Unit
@@ -18,7 +18,7 @@ def test =
 
   def force[A](thunk: Unit ->{cap} A): A = thunk(u)
 
-  def forceWrapper[A](@unbox mx: Wrapper[Unit ->{cap} A]): Wrapper[A] =
+  def forceWrapper[A](@use mx: Wrapper[Unit ->{cap} A]): Wrapper[A] =
     // Γ ⊢ mx: Wrapper[□ {cap} Unit => A]
     // `force` should be typed as ∀(□ {cap} Unit -> A) A, but it can not
     strictMap[Unit ->{mx*} A, A](mx)(t => force[A](t)) // error // should work
diff --git a/tests/neg-custom-args/captures/i21614.scala b/tests/neg-custom-args/captures/i21614.scala
index a5ed25d818a5..69aef446e9e2 100644
--- a/tests/neg-custom-args/captures/i21614.scala
+++ b/tests/neg-custom-args/captures/i21614.scala
@@ -1,12 +1,12 @@
 import language.experimental.captureChecking
 import caps.Capability
-import caps.unbox
+import caps.use
 
 trait File extends Capability
 class Logger(f: File^) extends Capability // <- will work if we remove the extends clause
 
-def mkLoggers1[F <: File^](@unbox files: List[F]): List[Logger^] =
+def mkLoggers1[F <: File^](@use files: List[F]): List[Logger^] =
   files.map((f: F) => new Logger(f)) // error, Q: can we make this pass (see #19076)?
 
-def mkLoggers2(@unbox files: List[File^]): List[Logger^] =
+def mkLoggers2(@use files: List[File^]): List[Logger^] =
   files.map(new Logger(_)) // error, Q: can we improve the error message?
diff --git a/tests/neg-custom-args/captures/leak-problem-2.scala b/tests/neg-custom-args/captures/leak-problem-2.scala
index 08a3a6c2d9ca..8ca298dbdd1e 100644
--- a/tests/neg-custom-args/captures/leak-problem-2.scala
+++ b/tests/neg-custom-args/captures/leak-problem-2.scala
@@ -2,7 +2,7 @@ import language.experimental.captureChecking
 
 trait Source[+T]
 
-def race[T](@caps.unbox sources: Seq[Source[T]^]): Source[T]^{sources*} = ???
+def race[T](@caps.use sources: Seq[Source[T]^]): Source[T]^{sources*} = ???
 
 def raceTwo[T](src1: Source[T]^, src2: Source[T]^): Source[T]^{}
   = race(Seq(src1, src2)) // error
diff --git a/tests/neg-custom-args/captures/reaches.scala b/tests/neg-custom-args/captures/reaches.scala
index 4db8d0df74d8..066c40031553 100644
--- a/tests/neg-custom-args/captures/reaches.scala
+++ b/tests/neg-custom-args/captures/reaches.scala
@@ -1,4 +1,4 @@
-import caps.unbox
+import caps.use
 class File:
   def write(): Unit = ???
 
@@ -11,7 +11,7 @@ class Ref[T](init: T):
   def get: T = x
   def set(y: T) = { x = y }
 
-def runAll0(@unbox xs: List[Proc]): Unit =
+def runAll0(@use xs: List[Proc]): Unit =
   var cur: List[() ->{xs*} Unit] = xs
   while cur.nonEmpty do
     val next: () ->{xs*} Unit = cur.head
@@ -21,7 +21,7 @@ def runAll0(@unbox xs: List[Proc]): Unit =
   usingFile: f =>
     cur = (() => f.write()) :: Nil // error
 
-def runAll1(@unbox xs: List[Proc]): Unit =
+def runAll1(@use xs: List[Proc]): Unit =
   val cur = Ref[List[() ->{xs*} Unit]](xs)  // OK, by revised VAR
   while cur.get.nonEmpty do
     val next: () ->{xs*} Unit = cur.get.head
@@ -78,5 +78,5 @@ def compose1[A, B, C](f: A => B, g: B => C): A ->{f, g} C =
 def mapCompose[A](ps: List[(A => A, A => A)]): List[A ->{ps*} A] =
   ps.map((x, y) => compose1(x, y)) // error // error
 
-def mapCompose2[A](@unbox ps: List[(A => A, A => A)]): List[A ->{ps*} A] =
+def mapCompose2[A](@use ps: List[(A => A, A => A)]): List[A ->{ps*} A] =
   ps.map((x, y) => compose1(x, y))
diff --git a/tests/neg-custom-args/captures/spread-problem.scala b/tests/neg-custom-args/captures/spread-problem.scala
index 579c7817b9c1..75f3a615cde8 100644
--- a/tests/neg-custom-args/captures/spread-problem.scala
+++ b/tests/neg-custom-args/captures/spread-problem.scala
@@ -2,7 +2,7 @@ import language.experimental.captureChecking
 
 trait Source[+T]
 
-def race[T](@caps.unbox sources: (Source[T]^)*): Source[T]^{sources*} = ???
+def race[T](@caps.use sources: (Source[T]^)*): Source[T]^{sources*} = ???
 
 def raceTwo[T](src1: Source[T]^, src2: Source[T]^): Source[T]^{} =
   race(Seq(src1, src2)*) // error
diff --git a/tests/neg-custom-args/captures/unbox-overrides.check b/tests/neg-custom-args/captures/unbox-overrides.check
index b9a3be7bffbc..dbffc164b5c5 100644
--- a/tests/neg-custom-args/captures/unbox-overrides.check
+++ b/tests/neg-custom-args/captures/unbox-overrides.check
@@ -2,20 +2,20 @@
 8 |  def foo(x: C): C        // error
   |      ^
   |error overriding method foo in trait A of type (x: C): C;
-  |  method foo of type (x: C): C has a parameter x with different @unbox status than the corresponding parameter in the overridden definition
+  |  method foo of type (x: C): C has a parameter x with different @use status than the corresponding parameter in the overridden definition
   |
   | longer explanation available when compiling with `-explain`
 -- [E164] Declaration Error: tests/neg-custom-args/captures/unbox-overrides.scala:9:6 ----------------------------------
-9 |  def bar(@unbox x: C): C // error
+9 |  def bar(@use x: C): C // error
   |      ^
   |error overriding method bar in trait A of type (x: C): C;
-  |  method bar of type (x: C): C has a parameter x with different @unbox status than the corresponding parameter in the overridden definition
+  |  method bar of type (x: C): C has a parameter x with different @use status than the corresponding parameter in the overridden definition
   |
   | longer explanation available when compiling with `-explain`
 -- [E164] Declaration Error: tests/neg-custom-args/captures/unbox-overrides.scala:15:15 --------------------------------
 15 |abstract class C extends A[C], B2 // error
    |               ^
    |error overriding method foo in trait A of type (x: C): C;
-   |  method foo in trait B2 of type (x: C): C has a parameter x with different @unbox status than the corresponding parameter in the overridden definition
+   |  method foo in trait B2 of type (x: C): C has a parameter x with different @use status than the corresponding parameter in the overridden definition
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/unbox-overrides.scala b/tests/neg-custom-args/captures/unbox-overrides.scala
index 5abb5013bfbe..6164ca274eaf 100644
--- a/tests/neg-custom-args/captures/unbox-overrides.scala
+++ b/tests/neg-custom-args/captures/unbox-overrides.scala
@@ -1,15 +1,15 @@
-import caps.unbox
+import caps.use
 
 trait A[X]:
-  def foo(@unbox x: X): X
+  def foo(@use x: X): X
   def bar(x: X): X
 
 trait B extends A[C]:
   def foo(x: C): C        // error
-  def bar(@unbox x: C): C // error
+  def bar(@use x: C): C // error
 
 trait B2:
   def foo(x: C): C
-  def bar(@unbox x: C): C
+  def bar(@use x: C): C
 
 abstract class C extends A[C], B2 // error
diff --git a/tests/neg/i20503.scala b/tests/neg/i20503.scala
index 3fb0573f6c2f..828b6ce71137 100644
--- a/tests/neg/i20503.scala
+++ b/tests/neg/i20503.scala
@@ -1,5 +1,5 @@
 import language.experimental.captureChecking
-import caps.unbox
+import caps.use
 
 class List[+A]:
   def head: A = ???
@@ -8,7 +8,7 @@ class List[+A]:
   def foreach[U](f: A => U): Unit = ???
   def nonEmpty: Boolean = ???
 
-def runOps(@unbox ops: List[() => Unit]): Unit =
+def runOps(@use ops: List[() => Unit]): Unit =
   // See i20156, due to limitation in expressiveness of current system,
   // we could map over the list of impure elements. OK with existentials.
   ops.foreach(op => op())
diff --git a/tests/neg/leak-problem-unboxed.scala b/tests/neg/leak-problem-unboxed.scala
index 7de3d84bfcca..aedd7c889112 100644
--- a/tests/neg/leak-problem-unboxed.scala
+++ b/tests/neg/leak-problem-unboxed.scala
@@ -1,5 +1,5 @@
 import language.experimental.captureChecking
-import caps.unbox
+import caps.use
 
 // Some capabilities that should be used locally
 trait Async:
@@ -9,12 +9,12 @@ def usingAsync[X](op: Async^ => X): X = ???
 
 case class Box[+T](get: T)
 
-def useBoxedAsync(@unbox x: Box[Async^]): Unit =
+def useBoxedAsync(@use x: Box[Async^]): Unit =
   val t0 = x
   val t1 = t0.get // ok
   t1.read()
 
-def useBoxedAsync1(@unbox x: Box[Async^]): Unit = x.get.read() // ok
+def useBoxedAsync1(@use x: Box[Async^]): Unit = x.get.read() // ok
 
 def test(): Unit =
 
diff --git a/tests/neg/leak-problem.scala b/tests/neg/leak-problem.scala
index dea2496d6c77..c842280c0587 100644
--- a/tests/neg/leak-problem.scala
+++ b/tests/neg/leak-problem.scala
@@ -1,5 +1,5 @@
 import language.experimental.captureChecking
-import caps.unbox
+import caps.use
 
 // Some capabilities that should be used locally
 trait Async:
@@ -17,12 +17,12 @@ def useBoxedAsync(x: Box[Async^]): Unit =
 def useBoxedAsync1(x: Box[Async^]): Unit = x.get.read() // error
 
 def test(): Unit =
-  def useBoxedAsync(@unbox x: Box[Async^]): Unit =
+  def useBoxedAsync(@use x: Box[Async^]): Unit =
     val t0 = x
     val t1 = t0.get
     t1.read()
 
-  def useBoxedAsync1(@unbox x: Box[Async^]): Unit = x.get.read()
+  def useBoxedAsync1(@use x: Box[Async^]): Unit = x.get.read()
 
   val xs: Box[Async^] = ???
   val xsLambda = () => useBoxedAsync(xs) // error
diff --git a/tests/pos-custom-args/captures/Buffer.scala b/tests/pos-custom-args/captures/Buffer.scala
index 2412e5b388ca..9ecd51ffa62a 100644
--- a/tests/pos-custom-args/captures/Buffer.scala
+++ b/tests/pos-custom-args/captures/Buffer.scala
@@ -10,7 +10,7 @@ trait Buffer[A]:
     val s = 10
      // capture checking: we need the copy since we box/unbox on g* on the next line
       // TODO: This looks fishy, need to investigate
-      // Alternative would be to mark `f` as @unbox. It's not inferred
+      // Alternative would be to mark `f` as @use. It's not inferred
       // since `^ appears in a function result, not under a box.
     val newElems = new Array[(IterableOnce[A]^{f})](s)
     var i = 0
diff --git a/tests/pos-custom-args/captures/dep-reach.scala b/tests/pos-custom-args/captures/dep-reach.scala
index c81197aa738d..1ee6fc3d17f9 100644
--- a/tests/pos-custom-args/captures/dep-reach.scala
+++ b/tests/pos-custom-args/captures/dep-reach.scala
@@ -1,10 +1,10 @@
-import caps.unbox
+import caps.use
 object Test:
   class C
   type Proc = () => Unit
 
   def f(c: C^, d: C^): () ->{c, d} Unit =
-    def foo(@unbox xs: Proc*): () ->{xs*} Unit =
+    def foo(@use xs: Proc*): () ->{xs*} Unit =
       xs.head
     val a: () ->{c} Unit = () => ()
     val b: () ->{d} Unit = () => ()
@@ -13,7 +13,7 @@ object Test:
 
   def g(c: C^, d: C^): () ->{c, d} Unit =
 
-    def foo(@unbox xs: Seq[() => Unit]): () ->{xs*} Unit =
+    def foo(@use xs: Seq[() => Unit]): () ->{xs*} Unit =
       xs.head
 
     val a: () ->{c} Unit = () => ()
diff --git a/tests/pos-custom-args/captures/gears-problem.scala b/tests/pos-custom-args/captures/gears-problem.scala
index 74f108f93e80..c6ef72bc421e 100644
--- a/tests/pos-custom-args/captures/gears-problem.scala
+++ b/tests/pos-custom-args/captures/gears-problem.scala
@@ -1,5 +1,5 @@
 import language.experimental.captureChecking
-import caps.unbox
+import caps.use
 
 trait Future[+T]:
   def await: T
@@ -11,7 +11,7 @@ class Collector[T](val futures: Seq[Future[T]^]):
   val results: Channel[Future[T]^{futures*}] = ???
 end Collector
 
-extension [T](@unbox fs: Seq[Future[T]^])
+extension [T](@use fs: Seq[Future[T]^])
   def awaitAll =
     val collector: Collector[T]{val futures: Seq[Future[T]^{fs*}]}
        = Collector(fs)
diff --git a/tests/pos-custom-args/captures/path-use.scala b/tests/pos-custom-args/captures/path-use.scala
index 181afc41bcc2..629fa04315a7 100644
--- a/tests/pos-custom-args/captures/path-use.scala
+++ b/tests/pos-custom-args/captures/path-use.scala
@@ -1,5 +1,5 @@
 import language.experimental.namedTuples
-import caps.unbox
+import caps.use
 
 class IO
 
@@ -9,7 +9,7 @@ class C(val f: IO^):
 type Proc = () => Unit
 
 def test(io: IO^) =
-  def test1(@unbox c: C { val f: IO^{io}}^{io}) =
+  def test1(@use c: C { val f: IO^{io}}^{io}) =
     val f = () => println(c.f)
     val _: () ->{c.f} Unit = f
 
@@ -19,3 +19,4 @@ def test(io: IO^) =
     val g = () => println(c.procs.head)
     val _: () ->{c.procs*} Unit = g
   test1(C(io))
+
diff --git a/tests/pos-custom-args/captures/reaches.scala b/tests/pos-custom-args/captures/reaches.scala
index ab0da9b67d18..cbe88e60020b 100644
--- a/tests/pos-custom-args/captures/reaches.scala
+++ b/tests/pos-custom-args/captures/reaches.scala
@@ -1,4 +1,4 @@
-import caps.unbox
+import caps.use
 
 class C
 def f(xs: List[C^]) =
@@ -22,7 +22,7 @@ extension [A](x: A) def :: (xs: List[A]): List[A] = ???
 
 object Nil extends List[Nothing]
 
-def runAll(@unbox xs: List[Proc]): Unit =
+def runAll(@use xs: List[Proc]): Unit =
   var cur: List[() ->{xs*} Unit] = xs  // OK, by revised VAR
   while cur.nonEmpty do
     val next: () ->{xs*} Unit = cur.head
diff --git a/tests/pos/Buffer.scala b/tests/pos/Buffer.scala
index 2412e5b388ca..9ecd51ffa62a 100644
--- a/tests/pos/Buffer.scala
+++ b/tests/pos/Buffer.scala
@@ -10,7 +10,7 @@ trait Buffer[A]:
     val s = 10
      // capture checking: we need the copy since we box/unbox on g* on the next line
       // TODO: This looks fishy, need to investigate
-      // Alternative would be to mark `f` as @unbox. It's not inferred
+      // Alternative would be to mark `f` as @use. It's not inferred
       // since `^ appears in a function result, not under a box.
     val newElems = new Array[(IterableOnce[A]^{f})](s)
     var i = 0
diff --git a/tests/pos/cc-poly-source-capability.scala b/tests/pos/cc-poly-source-capability.scala
index 3b6c0bde1398..363f261dadc1 100644
--- a/tests/pos/cc-poly-source-capability.scala
+++ b/tests/pos/cc-poly-source-capability.scala
@@ -1,7 +1,7 @@
 import language.experimental.captureChecking
 import annotation.experimental
 import caps.{CapSet, Capability}
-import caps.unbox
+import caps.use
 
 @experimental object Test:
 
@@ -18,7 +18,7 @@ import caps.unbox
 
     def allListeners: Set[Listener^{X^}] = listeners
 
-  def test1(async1: Async, @unbox others: List[Async]) =
+  def test1(async1: Async, @use others: List[Async]) =
     val src = Source[CapSet^{async1, others*}]
     val lst1 = listener(async1)
     val lsts = others.map(listener)
diff --git a/tests/pos/cc-poly-source.scala b/tests/pos/cc-poly-source.scala
index 4cfbbaa06936..2de5c6d67340 100644
--- a/tests/pos/cc-poly-source.scala
+++ b/tests/pos/cc-poly-source.scala
@@ -1,7 +1,7 @@
 import language.experimental.captureChecking
 import annotation.experimental
 import caps.{CapSet, Capability}
-import caps.unbox
+import caps.use
 
 @experimental object Test:
 
@@ -25,7 +25,7 @@ import caps.unbox
     val ls = src.allListeners
     val _: Set[Listener^{lbl1, lbl2}] = ls
 
-  def test2(@unbox lbls: List[Label^]) =
+  def test2(@use lbls: List[Label^]) =
     def makeListener(lbl: Label^): Listener^{lbl} = ???
     val listeners = lbls.map(makeListener)
     val src = Source[CapSet^{lbls*}]
diff --git a/tests/pos/gears-probem-1.scala b/tests/pos/gears-probem-1.scala
index ab71616b72fc..d363515afece 100644
--- a/tests/pos/gears-probem-1.scala
+++ b/tests/pos/gears-probem-1.scala
@@ -1,5 +1,5 @@
 import language.experimental.captureChecking
-import caps.unbox
+import caps.use
 
 trait Future[+T]:
   def await: T
@@ -17,7 +17,7 @@ class Result[+T, +E]:
 case class Err[+E](e: E) extends Result[Nothing, E]
 case class Ok[+T](x: T) extends Result[T, Nothing]
 
-extension [T](@unbox fs: Seq[Future[T]^])
+extension [T](@use fs: Seq[Future[T]^])
   def awaitAll =
     val collector//: Collector[T]{val futures: Seq[Future[T]^{fs*}]}
        = Collector(fs)
diff --git a/tests/pos/i18699.scala b/tests/pos/i18699.scala
index 1937d7dca8c5..5a0a9357f774 100644
--- a/tests/pos/i18699.scala
+++ b/tests/pos/i18699.scala
@@ -1,9 +1,9 @@
 import language.experimental.captureChecking
-import caps.unbox
+import caps.use
 
 trait Cap:
   def use: Int = 42
 
-def test2(@unbox cs: List[Cap^]): Unit =
+def test2(@use cs: List[Cap^]): Unit =
   val t0: Cap^{cs*} = cs.head  // error
   var t1: Cap^{cs*} = cs.head  // error
diff --git a/tests/pos/reach-capability.scala b/tests/pos/reach-capability.scala
index 50ea479ec3c1..08e82a1dabe9 100644
--- a/tests/pos/reach-capability.scala
+++ b/tests/pos/reach-capability.scala
@@ -1,7 +1,7 @@
 import language.experimental.captureChecking
 import annotation.experimental
 import caps.Capability
-import caps.unbox
+import caps.use
 
 @experimental object Test2:
 
@@ -12,7 +12,7 @@ import caps.unbox
 
   class Listener
 
-  def test2(@unbox lbls: List[Label]) =
+  def test2(@use lbls: List[Label]) =
     def makeListener(lbl: Label): Listener^{lbl} = ???
     val listeners = lbls.map(makeListener) // should work
 
diff --git a/tests/pos/reach-problem.scala b/tests/pos/reach-problem.scala
index d6b7b79011a6..f36a4af14ad2 100644
--- a/tests/pos/reach-problem.scala
+++ b/tests/pos/reach-problem.scala
@@ -1,11 +1,11 @@
 import language.experimental.captureChecking
-import caps.unbox
+import caps.use
 
 class Box[T](items: Seq[T^]):
   def getOne: T^{items*} = ???
 
 object Box:
-  def getOne[T](@unbox items: Seq[T^]): T^{items*} =
+  def getOne[T](@use items: Seq[T^]): T^{items*} =
     val bx = Box(items)
     bx.getOne
 /*

From 7c2a76b943c34502493adbd4375ebbe713b79c69 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Wed, 30 Oct 2024 18:34:09 +0100
Subject: [PATCH 203/306] Make sure we don't lose `erased` in method types on
 Setup

---
 compiler/src/dotty/tools/dotc/cc/Setup.scala  |  5 ++-
 .../src/dotty/tools/dotc/core/Types.scala     | 34 +++++++++++--------
 .../captures/erased-methods.scala             | 20 +++++++++++
 3 files changed, 43 insertions(+), 16 deletions(-)
 create mode 100644 tests/pos-custom-args/captures/erased-methods.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index a64703bf059e..4df157ed42e7 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -535,13 +535,16 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
               // substitute `x.f.type`, `x` becomes a `TermParamRef`. But the new method
               // type is still under initialization and `paramInfos` is still `null`,
               // so the new `NamedType` will not have a denoation.
+              def adaptedInfo(psym: Symbol, info: mt.PInfo): mt.PInfo = mt.companion match
+                case mtc: MethodTypeCompanion => mtc.adaptParamInfo(psym, info).asInstanceOf[mt.PInfo]
+                case _ => info
               mt.companion(mt.paramNames)(
                 mt1 =>
                   if !paramSignatureChanges && !mt.isParamDependent && prevLambdas.isEmpty then
                     mt.paramInfos
                   else
                     val subst = SubstParams(psyms :: prevPsymss, mt1 :: prevLambdas)
-                    psyms.map(psym => subst(psym.nextInfo).asInstanceOf[mt.PInfo]),
+                    psyms.map(psym => adaptedInfo(psym, subst(psym.nextInfo).asInstanceOf[mt.PInfo])),
                 mt1 =>
                   integrateRT(mt.resType, psymss.tail, resType, psyms :: prevPsymss, mt1 :: prevLambdas)
               )
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index e497c541166c..62bbd2be2773 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -4175,24 +4175,28 @@ object Types extends TypeUtils {
      *   - wrap types of parameters that have an @allowConversions annotation with Into[_]
      */
     def fromSymbols(params: List[Symbol], resultType: Type)(using Context): MethodType =
+      apply(params.map(_.name.asTermName))(
+         tl => params.map(p => tl.integrate(params, adaptParamInfo(p))),
+         tl => tl.integrate(params, resultType))
+
+    /** Adapt info of parameter symbol to be integhrated into corresponding MethodType
+     *  using the scheme described in `fromSymbols`.
+     */
+    def adaptParamInfo(param: Symbol, pinfo: Type)(using Context): Type =
       def addAnnotation(tp: Type, cls: ClassSymbol, param: Symbol): Type = tp match
         case ExprType(resType) => ExprType(addAnnotation(resType, cls, param))
         case _ => AnnotatedType(tp, Annotation(cls, param.span))
-
-      def paramInfo(param: Symbol) =
-        var paramType = param.info
-          .annotatedToRepeated
-          .mapIntoAnnot(defn.IntoAnnot, defn.IntoParamAnnot)
-        if param.is(Inline) then
-          paramType = addAnnotation(paramType, defn.InlineParamAnnot, param)
-        if param.is(Erased) then
-          paramType = addAnnotation(paramType, defn.ErasedParamAnnot, param)
-        paramType
-
-      apply(params.map(_.name.asTermName))(
-         tl => params.map(p => tl.integrate(params, paramInfo(p))),
-         tl => tl.integrate(params, resultType))
-    end fromSymbols
+      var paramType = pinfo
+        .annotatedToRepeated
+        .mapIntoAnnot(defn.IntoAnnot, defn.IntoParamAnnot)
+      if param.is(Inline) then
+        paramType = addAnnotation(paramType, defn.InlineParamAnnot, param)
+      if param.is(Erased) then
+        paramType = addAnnotation(paramType, defn.ErasedParamAnnot, param)
+      paramType
+
+    def adaptParamInfo(param: Symbol)(using Context): Type =
+      adaptParamInfo(param, param.info)
 
     def apply(paramNames: List[TermName])(paramInfosExp: MethodType => List[Type], resultTypeExp: MethodType => Type)(using Context): MethodType =
       checkValid(unique(new CachedMethodType(paramNames)(paramInfosExp, resultTypeExp, self)))
diff --git a/tests/pos-custom-args/captures/erased-methods.scala b/tests/pos-custom-args/captures/erased-methods.scala
new file mode 100644
index 000000000000..911c779e08e5
--- /dev/null
+++ b/tests/pos-custom-args/captures/erased-methods.scala
@@ -0,0 +1,20 @@
+import language.experimental.saferExceptions
+import language.experimental.erasedDefinitions
+import language.experimental.captureChecking
+
+class Ex1 extends Exception("Ex1")
+class Ex2 extends Exception("Ex2")
+class Ex3 extends Exception("Ex3")
+
+def foo8a(i: Int) =
+  (erased xx1: CanThrow[Ex2]^) ?=> throw new Ex2
+
+def foo9a(i: Int)
+  : (erased x$0: CanThrow[Ex3]^)
+    ?=> (erased x$1: CanThrow[Ex2]^)
+    ?=> (erased x$2: CanThrow[Ex1]^)
+    ?=> Unit
+  = (erased x$1: CanThrow[Ex3]^)
+     ?=> (erased x$2: CanThrow[Ex2]^)
+     ?=> (erased x$3: CanThrow[Ex1]^)
+     ?=> throw new Ex3

From 2747f0329dadee5ec67f7db30c1dad8f2f1796d3 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Wed, 30 Oct 2024 19:48:25 +0100
Subject: [PATCH 204/306] Drop curried use scheme

Drop the scheme where we only charge the last arrow of a curried lambda with
elements used in the body. On the one hand, this is unsound without compensation
measures (like, restricting to reach capabilities, or taking all capture sets
of a named curried function as the underlying reference). On the other hand, this
should be generalized to all closures and anonymous functions forming the right
hand sides of methods.
---
 compiler/src/dotty/tools/dotc/cc/CaptureOps.scala   |  3 +++
 .../src/dotty/tools/dotc/cc/CheckCaptures.scala     |  9 ++++++---
 compiler/src/dotty/tools/dotc/cc/Setup.scala        |  2 +-
 .../captures/curried-closures.scala                 |  2 +-
 tests/neg-custom-args/captures/i21620.check         | 13 +++++++++++++
 tests/neg-custom-args/captures/i21620.scala         | 11 +++++++++++
 tests/neg-custom-args/captures/leaked-curried.check |  6 ++++--
 tests/pos-custom-args/captures/i21620.scala         | 11 -----------
 8 files changed, 39 insertions(+), 18 deletions(-)
 rename tests/{pos-custom-args => neg-custom-args}/captures/curried-closures.scala (91%)
 delete mode 100644 tests/pos-custom-args/captures/i21620.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index f9c33695e9fe..e4d80b7f6982 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -40,6 +40,9 @@ object ccConfig:
    */
   inline val handleEtaExpansionsSpecially = false
 
+  /** If enabled we drop inner uses in outer arrows of a curried function */
+  inline val DropOuterUsesInCurried = false
+
   /** If true, use existential capture set variables */
   def useExistentials(using Context) =
     Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.5`)
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 5b4105a0b778..902965c13476 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -36,7 +36,8 @@ object CheckCaptures:
     case NestedInOwner  // 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).
-    case ClosureResult  // environment is for the result of a closure
+    case ClosureResult  // environment is for the result of a closure,
+                        // used only under ccConfig.DropOuterUsesInCurried
     case Boxed          // environment is inside a box (in which case references are not counted)
 
   /** A class describing environments.
@@ -183,7 +184,9 @@ object CheckCaptures:
     if ccConfig.useSealed then check.traverse(tp)
   end disallowRootCapabilitiesIn
 
-  /** Attachment key for bodies of closures, provided they are values */
+  /** Attachment key for bodies of closures, provided they are values.
+   *  Used only under ccConfig.DropOuterUsesInCurried
+   */
   val ClosureBodyValue = Property.Key[Unit]
 
   /** A prototype that indicates selection with an immutable value */
@@ -733,7 +736,7 @@ class CheckCaptures extends Recheck, SymTransformer:
 
     override def recheckClosureBlock(mdef: DefDef, expr: Closure, pt: Type)(using Context): Type =
       mdef.rhs match
-        case rhs @ closure(_, _, _) =>
+        case rhs @ closure(_, _, _) if ccConfig.DropOuterUsesInCurried =>
           // In a curried closure `x => y => e` don't leak capabilities retained by
           // the second closure `y => e` into the first one. This is an approximation
           // of the CC rule which says that a closure contributes captures to its
diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index 4df157ed42e7..3593e00ad8b8 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -302,7 +302,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
               case _ => res
           )
         val fntpe = defn.PolyFunctionOf(mt)
-        if !encl.isEmpty && resDecomposed.isEmpty then
+        if !encl.isEmpty && (!ccConfig.DropOuterUsesInCurried || resDecomposed.isEmpty) then
           val cs = CaptureSet(encl.map(_.paramRefs.head)*)
           CapturingType(fntpe, cs, boxed = false)
         else fntpe
diff --git a/tests/pos-custom-args/captures/curried-closures.scala b/tests/neg-custom-args/captures/curried-closures.scala
similarity index 91%
rename from tests/pos-custom-args/captures/curried-closures.scala
rename to tests/neg-custom-args/captures/curried-closures.scala
index 262dd4b66b92..426f0df85022 100644
--- a/tests/pos-custom-args/captures/curried-closures.scala
+++ b/tests/neg-custom-args/captures/curried-closures.scala
@@ -30,5 +30,5 @@ def Test4(g: OutputStream^) =
   val _: (f: OutputStream^) ->{} Int ->{f} Unit = later
 
   val later2 = () => (y: Int) => xs.foreach(x => g.write(x + y))
-  val _: () ->{} Int ->{g} Unit = later2
+  val _: () ->{} Int ->{g} Unit = later2 // error, inferred type is () ->{later2} Int ->{g} Unit
 
diff --git a/tests/neg-custom-args/captures/i21620.check b/tests/neg-custom-args/captures/i21620.check
index 3a09ba978574..ddfcdafab36f 100644
--- a/tests/neg-custom-args/captures/i21620.check
+++ b/tests/neg-custom-args/captures/i21620.check
@@ -4,6 +4,12 @@
   |      A pure expression does nothing in statement position
   |
   | longer explanation available when compiling with `-explain`
+-- [E129] Potential Issue Warning: tests/neg-custom-args/captures/i21620.scala:14:4 ------------------------------------
+14 |    x
+   |    ^
+   |    A pure expression does nothing in statement position
+   |
+   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i21620.scala:9:31 ----------------------------------------
 9 |  val _: () -> () ->{x} Unit = f // error
   |                               ^
@@ -11,3 +17,10 @@
   |                               Required: () -> () ->{x} Unit
   |
   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i21620.scala:20:33 ---------------------------------------
+20 |  val _: () ->{} () ->{x} Unit = f   // error, but could be OK
+   |                                 ^
+   |                                 Found:    () ->{f} () ->{x} Unit
+   |                                 Required: () -> () ->{x} Unit
+   |
+   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/i21620.scala b/tests/neg-custom-args/captures/i21620.scala
index a21a41a10863..3b7ba5a9fd5a 100644
--- a/tests/neg-custom-args/captures/i21620.scala
+++ b/tests/neg-custom-args/captures/i21620.scala
@@ -8,3 +8,14 @@ def test(x: C^) =
     () => foo()
   val _: () -> () ->{x} Unit = f // error
   ()
+
+def test2(x: C^) =
+  def foo() =
+    x
+    ()
+  val f = () =>
+    // println() //  uncomenting would give an error, but with
+                 //  a different way of handling curried functions should be OK
+    () => foo()
+  val _: () ->{} () ->{x} Unit = f   // error, but could be OK
+  ()
diff --git a/tests/neg-custom-args/captures/leaked-curried.check b/tests/neg-custom-args/captures/leaked-curried.check
index 3f0a9800a4ec..63359e7bb8b8 100644
--- a/tests/neg-custom-args/captures/leaked-curried.check
+++ b/tests/neg-custom-args/captures/leaked-curried.check
@@ -1,8 +1,10 @@
 -- Error: tests/neg-custom-args/captures/leaked-curried.scala:14:20 ----------------------------------------------------
 14 |        () => () => io // error
    |                    ^^
-   |(io : Cap^) cannot be referenced here; it is not included in the allowed capture set {} of the self type of class Fuzz
+   |           (io : Cap^) cannot be referenced here; it is not included in the allowed capture set {}
+   |           of an enclosing function literal with expected type () -> () ->{io} (ex$7: caps.Exists) -> Cap^{ex$7}
 -- Error: tests/neg-custom-args/captures/leaked-curried.scala:17:20 ----------------------------------------------------
 17 |        () => () => io // error
    |                    ^^
-   |(io : Cap^) cannot be referenced here; it is not included in the allowed capture set {} of the self type of class Foo
+   |         (io : Cap^) cannot be referenced here; it is not included in the allowed capture set {}
+   |         of an enclosing function literal with expected type () -> () ->{io} (ex$15: caps.Exists) -> Cap^{ex$15}
diff --git a/tests/pos-custom-args/captures/i21620.scala b/tests/pos-custom-args/captures/i21620.scala
deleted file mode 100644
index b2c382aa4c75..000000000000
--- a/tests/pos-custom-args/captures/i21620.scala
+++ /dev/null
@@ -1,11 +0,0 @@
-class C
-def test(x: C^) =
-  def foo() =
-    x
-    ()
-  val f = () =>
-    // println() //  uncomenting would give an error, but with
-                 //  a different way of handling curried functions should be OK
-    () => foo()
-  val _: () -> () ->{x} Unit = f
-  ()

From 17a4a8c9f1d66a2f9333f7224d94abe9977ecac4 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Thu, 31 Oct 2024 11:45:57 +0100
Subject: [PATCH 205/306] Stop markFree at nested methods

Use sets of nested methods are anyway charged on call.
---
 compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala | 12 ++++++++++--
 compiler/src/dotty/tools/dotc/cc/Setup.scala         | 12 ++++++++++++
 2 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 902965c13476..0cd795b018f2 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -365,6 +365,12 @@ class CheckCaptures extends Recheck, SymTransformer:
       else
         i"\nof the enclosing ${owner.showLocated}"
 
+    def isOfNestedMethod(env: Env | Null)(using Context) =
+      env != null
+      && env.owner.is(Method)
+      && env.owner.owner.isTerm
+      && !env.owner.isAnonymousFunction
+
     /** Include `sym` in the capture sets of all enclosing environments nested in the
      *  the environment in which `sym` is defined.
      */
@@ -377,7 +383,8 @@ class CheckCaptures extends Recheck, SymTransformer:
           if env.isOpen && env.owner != sym.enclosure then
             capt.println(i"Mark $sym with cs ${ref.captureSet} free in ${env.owner}")
             checkElem(ref, env.captured, pos, provenance(env))
-            recur(nextEnvToCharge(env, _.owner != sym.enclosure))
+            if !isOfNestedMethod(env) then
+              recur(nextEnvToCharge(env, _.owner != sym.enclosure))
         recur(curEnv)
 
     /** Make sure (projected) `cs` is a subset of the capture sets of all enclosing
@@ -438,7 +445,8 @@ class CheckCaptures extends Recheck, SymTransformer:
             isVisible
           checkSubset(included, env.captured, pos, provenance(env))
           capt.println(i"Include call or box capture $included from $cs in ${env.owner} --> ${env.captured}")
-          recur(included, nextEnvToCharge(env, !_.owner.isStaticOwner))
+          if !isOfNestedMethod(env) then
+            recur(included, nextEnvToCharge(env, !_.owner.isStaticOwner))
       recur(cs, curEnv)
     end markFree
 
diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index 3593e00ad8b8..f3ca15a8634d 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -23,8 +23,20 @@ import dotty.tools.dotc.util.NoSourcePosition
 /** Operations accessed from CheckCaptures */
 trait SetupAPI:
   type DefRecheck = (tpd.ValOrDefDef, Symbol) => Context ?=> Type
+
+  /** Setup procedure to run for each compilation unit
+   *   @param tree       the typed tree of the unit to check
+   *   @param recheckDef the recheck method to run on completion of symbols with
+   *                     inferred (result-) types
+   */
   def setupUnit(tree: Tree, recheckDef: DefRecheck)(using Context): Unit
+
+  /** Symbol is a term member of a class that was not capture checked
+   *  The info of these symbols is made fluid.
+   */
   def isPreCC(sym: Symbol)(using Context): Boolean
+
+  /** Check to do after the capture checking traversal */
   def postCheck()(using Context): Unit
 
 object Setup:

From 02cd565fa5bad80094bdd6768a0312d8534bc067 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Thu, 31 Oct 2024 11:50:51 +0100
Subject: [PATCH 206/306] Allow reach capabilities from within a nested closure

---
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 32 ++++++---
 docs/_docs/internals/cc/use-design.md         | 71 +++++++++++++++++++
 .../captures/method-uses.scala                | 30 ++++++++
 3 files changed, 123 insertions(+), 10 deletions(-)
 create mode 100644 docs/_docs/internals/cc/use-design.md
 create mode 100644 tests/neg-custom-args/captures/method-uses.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 0cd795b018f2..844539f9a465 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -50,7 +50,8 @@ object CheckCaptures:
       owner: Symbol,
       kind: EnvKind,
       captured: CaptureSet,
-      outer0: Env | Null):
+      outer0: Env | Null,
+      nestedClosure: Symbol = NoSymbol):
 
     def outer = outer0.nn
 
@@ -400,8 +401,10 @@ class CheckCaptures extends Recheck, SymTransformer:
         else
           !sym.isContainedIn(env.owner)
 
-      def checkUseDeclared(c: CaptureRef, env: Env) =
-        c.pathRoot match
+      def checkUseDeclared(c: CaptureRef, env: Env, lastEnv: Env | Null) =
+        if lastEnv != null && env.nestedClosure.exists && env.nestedClosure == lastEnv.owner then
+          () // access is from a nested closure, so it's OK
+        else c.pathRoot match
           case ref: NamedType if !ref.symbol.hasAnnotation(defn.UseAnnot) =>
             val what = if ref.isType then "Capture set parameter" else "Local reach capability"
             report.error(
@@ -409,7 +412,7 @@ class CheckCaptures extends Recheck, SymTransformer:
                   |To allow this, the ${ref.symbol} should be declared with a @use annotation""", pos)
           case _ =>
 
-      def recur(cs: CaptureSet, env: Env)(using Context): Unit =
+      def recur(cs: CaptureSet, env: Env, lastEnv: Env | Null)(using Context): Unit =
         if env.isOpen && !env.owner.isStaticOwner && !cs.isAlwaysEmpty then
           // Only captured references that are visible from the environment
           // should be included.
@@ -423,7 +426,7 @@ class CheckCaptures extends Recheck, SymTransformer:
               c match
                 case ReachCapability(c1) =>
                   if c1.isParamPath then
-                    checkUseDeclared(c, env)
+                    checkUseDeclared(c, env, lastEnv)
                   else
                     // When a reach capabilty x* where `x` is not a parameter goes out
                     // of scope, we need to continue with `x`'s underlying deep capture set.
@@ -438,16 +441,16 @@ class CheckCaptures extends Recheck, SymTransformer:
                     capt.println(i"Widen reach $c to $underlying in ${env.owner}")
                     underlying.disallowRootCapability: () =>
                       report.error(em"Local reach capability $c leaks into capture scope of ${env.ownerString}", pos)
-                    recur(underlying, env)
+                    recur(underlying, env, lastEnv)
                 case c: TypeRef if c.isParamPath =>
-                  checkUseDeclared(c, env)
+                  checkUseDeclared(c, env, lastEnv)
                 case _ =>
             isVisible
           checkSubset(included, env.captured, pos, provenance(env))
           capt.println(i"Include call or box capture $included from $cs in ${env.owner} --> ${env.captured}")
           if !isOfNestedMethod(env) then
-            recur(included, nextEnvToCharge(env, !_.owner.isStaticOwner))
-      recur(cs, curEnv)
+            recur(included, nextEnvToCharge(env, !_.owner.isStaticOwner), env)
+      recur(cs, curEnv, null)
     end markFree
 
     /** Include references captured by the called method in the current environment stack */
@@ -843,10 +846,19 @@ class CheckCaptures extends Recheck, SymTransformer:
     override def recheckDefDef(tree: DefDef, sym: Symbol)(using Context): Type =
       if Synthetics.isExcluded(sym) then sym.info
       else
+        // If rhs ends in a closure or anonymous class, the corresponding symbol
+        def nestedClosure(rhs: Tree)(using Context): Symbol = rhs match
+          case Closure(_, meth, _) => meth.symbol
+          case Apply(fn, _) if fn.symbol.isConstructor && fn.symbol.owner.isAnonymousClass => fn.symbol.owner
+          case Block(_, expr) => nestedClosure(expr)
+          case Inlined(_, _, expansion) => nestedClosure(expansion)
+          case Typed(expr, _) => nestedClosure(expr)
+          case _ => NoSymbol
+
         val saved = curEnv
         val localSet = capturedVars(sym)
         if !localSet.isAlwaysEmpty then
-          curEnv = Env(sym, EnvKind.Regular, localSet, curEnv)
+          curEnv = Env(sym, EnvKind.Regular, localSet, curEnv, nestedClosure(tree.rhs))
 
         // ctx with AssumedContains entries for each Contains parameter
         val bodyCtx =
diff --git a/docs/_docs/internals/cc/use-design.md b/docs/_docs/internals/cc/use-design.md
new file mode 100644
index 000000000000..4732f45a84ab
--- /dev/null
+++ b/docs/_docs/internals/cc/use-design.md
@@ -0,0 +1,71 @@
+
+Possible design:
+
+ 1. Have @use annotation on type parameters and value parameters of regular methods
+   (not anonymous functions).
+ 2. In markFree, keep track whether a capture set variable or reach capability
+   is used directly in the method where it is defined, or in a nested context
+   (either unbound nested closure or unbound anonymous class).
+ 3. Disallow charging a reach capability `xs*` to the environment of the method where
+   `xs` is a parameter unless `xs` is declared `@use`.
+ 4. Analogously, disallow charging a capture set variable `C^` to the environment of the method where `C^` is a parameter unless `C^` is declared `@use`.
+ 5. When passing an argument to a `@use`d term parameter, charge the `dcs` of the argument type to the environments via markFree.
+ 6. When instantiating a `@use`d type parameter, charge the capture set of the argument
+   to the environments via markFree.
+
+It follows that we cannot refer to methods with @use term parameters as values. Indeed,
+their eta expansion would produce an anonymous function that includes a reach capability of
+its parameter in its use set, violating (3).
+
+Example:
+
+```scala
+  def runOps(@use ops: List[() => Unit]): Unit = ops.foreach(_())
+```
+Then `runOps` expands to
+```scala
+(xs: List[() => Unit]) => runOps(xs)
+```
+Note that `xs` does not carry a `@use` since this is disallowed by (1) for anonymous functions. By (5), we charge the deep capture set of `xs`, which is `xs*` to the environment. By (3), this is actually disallowed.
+
+Now, if we express this with explicit capture set parameters we get:
+```scala
+  def runOpsPoly[@use C^](ops: List[() ->{C^} Unit]): Unit = ops.foreach[C^](_())
+```
+Then `runOpsPoly` expands to `runOpsPoly[cs]` for some inferred capture set `cs`. And this expands to:
+```scala
+(xs: List[() ->{cs} Unit]) => runOpsPoly[cs](xs)
+```
+Since `cs` is passed to the `@use` parameter of `runOpsPoly` it is charged
+to the environment of the function body, so the type of the previous expression is
+```scala
+List[() ->{cs} Unit]) ->{cs} Unit
+```
+
+We can also use explicit capture set parameters to eta expand the first `runOps` manually:
+
+```scala
+[C^] => (xs: List[() ->{C^} Unit]) => runOps(xs)
+  : [C^] -> List[() ->{C^} Unit] ->[C^] Unit
+```
+Except that this currently runs afoul of the implementation restriction that polymorphic functions cannot wrap capturing functions. But that's a restriction we need to lift anyway.
+
+## `@use` inference
+
+ - `@use` is implied for a term parameter `x` of a method if `x`'s type contains a boxed cap and `x` or `x*` is not referred to in the result type of the method.
+
+ - `@use` is implied for a capture set parameter `C` of a method if `C` is not referred to in the result type of the method.
+
+If `@use` is implied, one can override to no use by giving an explicit use annotation
+`@use(false)` instead. Example:
+```scala
+  def f(@use(false) xs: List[() => Unit]): Int = xs.length
+```
+
+This works since `@use` is defined like this:
+```scala
+class use(cond: Boolean = true) extends StaticAnnotation
+```
+
+
+
diff --git a/tests/neg-custom-args/captures/method-uses.scala b/tests/neg-custom-args/captures/method-uses.scala
new file mode 100644
index 000000000000..4dad7119a8e4
--- /dev/null
+++ b/tests/neg-custom-args/captures/method-uses.scala
@@ -0,0 +1,30 @@
+def test(xs: List[() => Unit]) =
+  xs.head // error
+
+  def foo =
+    xs.head // ok
+  def bar() =
+    xs.head // ok
+
+  class Foo:
+    println(xs.head) // error, but could be OK
+
+  foo // error
+  bar() // error
+  Foo() // OK, but could be error
+
+def test2(xs: List[() => Unit]) =
+  def foo = xs.head // ok
+  ()
+
+def test3(xs: List[() => Unit]): () ->{xs*} Unit = () =>
+  println(xs.head)  // ok
+
+  def test4(xs: List[() => Unit]) = () => xs.head // ok
+
+  def test5(xs: List[() => Unit]) = new:
+    println(xs.head) // ok
+
+  def test6(xs: List[() => Unit]) =
+    val x= new { println(xs.head) } // error
+    x

From e6b08de2d4b8a8fe7cb85cb92be39037d74ddc04 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Thu, 31 Oct 2024 14:50:07 +0100
Subject: [PATCH 207/306] Drop code supporting previous unsound scheme for
 curried lambdas

---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  |  3 --
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 29 ++-----------------
 compiler/src/dotty/tools/dotc/cc/Setup.scala  |  2 +-
 3 files changed, 3 insertions(+), 31 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index e4d80b7f6982..f9c33695e9fe 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -40,9 +40,6 @@ object ccConfig:
    */
   inline val handleEtaExpansionsSpecially = false
 
-  /** If enabled we drop inner uses in outer arrows of a curried function */
-  inline val DropOuterUsesInCurried = false
-
   /** If true, use existential capture set variables */
   def useExistentials(using Context) =
     Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.5`)
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 844539f9a465..5e4afe542922 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -36,8 +36,6 @@ object CheckCaptures:
     case NestedInOwner  // 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).
-    case ClosureResult  // environment is for the result of a closure,
-                        // used only under ccConfig.DropOuterUsesInCurried
     case Boxed          // environment is inside a box (in which case references are not counted)
 
   /** A class describing environments.
@@ -185,11 +183,6 @@ object CheckCaptures:
     if ccConfig.useSealed then check.traverse(tp)
   end disallowRootCapabilitiesIn
 
-  /** Attachment key for bodies of closures, provided they are values.
-   *  Used only under ccConfig.DropOuterUsesInCurried
-   */
-  val ClosureBodyValue = Property.Key[Unit]
-
   /** A prototype that indicates selection with an immutable value */
   class PathSelectionProto(val sym: Symbol, val pt: Type)(using Context) extends WildcardSelectionProto
 
@@ -339,20 +332,13 @@ class CheckCaptures extends Recheck, SymTransformer:
 
     /** The next environment enclosing `env` that needs to be charged
      *  with free references.
-     *  Skips environments directly enclosing environments of kind ClosureResult.
      *  @param included Whether an environment is included in the range of
      *                  environments to charge. Once `included` is false, no
      *                  more environments need to be charged.
      */
     def nextEnvToCharge(env: Env, included: Env => Boolean)(using Context): Env =
-      var nextEnv = env.outer
-      if env.owner.isConstructor then
-        if included(nextEnv) then nextEnv = nextEnv.outer
-      if env.kind == EnvKind.ClosureResult then
-        // skip this one
-        nextEnvToCharge(nextEnv, included)
-      else
-        nextEnv
+      if env.owner.isConstructor && included(env.outer) then env.outer.outer
+      else env.outer
 
     /** A description where this environment comes from */
     private def provenance(env: Env)(using Context): String =
@@ -746,15 +732,6 @@ class CheckCaptures extends Recheck, SymTransformer:
         .showing(i"rechecked closure $tree / $pt = $result", capt)
 
     override def recheckClosureBlock(mdef: DefDef, expr: Closure, pt: Type)(using Context): Type =
-      mdef.rhs match
-        case rhs @ closure(_, _, _) if ccConfig.DropOuterUsesInCurried =>
-          // In a curried closure `x => y => e` don't leak capabilities retained by
-          // the second closure `y => e` into the first one. This is an approximation
-          // of the CC rule which says that a closure contributes captures to its
-          // environment only if a let-bound reference to the closure is used.
-          mdef.rhs.putAttachment(ClosureBodyValue, ())
-        case _ =>
-
       openClosures = (mdef.symbol, pt) :: openClosures
       try
         // Constrain closure's parameters and result from the expected type before
@@ -1002,8 +979,6 @@ class CheckCaptures extends Recheck, SymTransformer:
       tree match
         case _: RefTree | closureDef(_) if pt.isBoxedCapturing =>
           curEnv = Env(curEnv.owner, EnvKind.Boxed, CaptureSet.Var(curEnv.owner, level = currentLevel), curEnv)
-        case _ if tree.hasAttachment(ClosureBodyValue) =>
-          curEnv = Env(curEnv.owner, EnvKind.ClosureResult, CaptureSet.Var(curEnv.owner, level = currentLevel), curEnv)
         case _ =>
       val res =
         try
diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index f3ca15a8634d..56afaa1b33fb 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -314,7 +314,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
               case _ => res
           )
         val fntpe = defn.PolyFunctionOf(mt)
-        if !encl.isEmpty && (!ccConfig.DropOuterUsesInCurried || resDecomposed.isEmpty) then
+        if !encl.isEmpty then
           val cs = CaptureSet(encl.map(_.paramRefs.head)*)
           CapturingType(fntpe, cs, boxed = false)
         else fntpe

From fd9e895e35c5d8ce5a4eba678b1bdae45ea9c747 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Thu, 31 Oct 2024 15:05:24 +0100
Subject: [PATCH 208/306] Re-enable handleEtaExpansionsSpecially setting

This gives better error messages. Previously we thought this would
make reach capabilities unsound, but I don't see an issue with the latest
design.
---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  |  8 +-----
 .../src/dotty/tools/dotc/core/Types.scala     | 28 ++++++++-----------
 .../captures/effect-swaps-explicit.check      |  4 +--
 tests/neg-custom-args/captures/i21614.check   | 18 ++++++++----
 tests/neg-custom-args/captures/i21614.scala   |  2 +-
 tests/neg-custom-args/captures/levels.check   |  7 +++--
 .../captures/vars-simple.check                |  8 ++++--
 tests/neg-custom-args/captures/vars.check     |  7 +++--
 8 files changed, 44 insertions(+), 38 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index f9c33695e9fe..31ddfcc93bbc 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -27,18 +27,12 @@ object ccConfig:
    */
   inline val allowUnsoundMaps = false
 
-  /** If true, when computing the memberinfo of a refined type created
-   *  by addCaptureRefinements take the refineInfo directly without intersecting
-   *  with the parent info.
-   */
-  inline val optimizedRefinements = false
-
   /** If enabled, use a special path in recheckClosure for closures
    *  that are eta expansions. This can improve some error messages but
    *  currently leads to unsoundess for handling reach capabilities.
    *  TODO: The unsoundness needs followin up.
    */
-  inline val handleEtaExpansionsSpecially = false
+  inline val handleEtaExpansionsSpecially = true
 
   /** If true, use existential capture set variables */
   def useExistentials(using Context) =
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 62bbd2be2773..87398000a461 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -863,23 +863,19 @@ object Types extends TypeUtils {
         }
         else
           val isRefinedMethod = rinfo.isInstanceOf[MethodOrPoly]
-          rinfo match
-            case CapturingType(_, refs: CaptureSet.RefiningVar) if ccConfig.optimizedRefinements =>
-              pdenot.asSingleDenotation.derivedSingleDenotation(pdenot.symbol, rinfo)
+          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
+                || name == nme.apply && defn.isFunctionType(tp.parent)) =>
+              // use `rinfo` to keep the right parameter names for named args. See i8516.scala.
+              joint.derivedSingleDenotation(joint.symbol, rinfo, pre, isRefinedMethod)
             case _ =>
-              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
-                    || name == nme.apply && defn.isFunctionType(tp.parent)) =>
-                  // use `rinfo` to keep the right parameter names for named args. See i8516.scala.
-                  joint.derivedSingleDenotation(joint.symbol, rinfo, pre, isRefinedMethod)
-                case _ =>
-                  joint
+              joint
       }
 
       def goApplied(tp: AppliedType, tycon: HKTypeLambda) =
diff --git a/tests/neg-custom-args/captures/effect-swaps-explicit.check b/tests/neg-custom-args/captures/effect-swaps-explicit.check
index 264dfa663d39..47559ab97568 100644
--- a/tests/neg-custom-args/captures/effect-swaps-explicit.check
+++ b/tests/neg-custom-args/captures/effect-swaps-explicit.check
@@ -25,5 +25,5 @@
 -- Error: tests/neg-custom-args/captures/effect-swaps-explicit.scala:68:15 ---------------------------------------------
 68 |        Result.make: //lbl ?=> // error, escaping label from Result
    |        ^^^^^^^^^^^
-   |local reference contextual$9 from (using contextual$9: boundary.Label[Result[box Future[box T^?]^{fr, contextual$9, contextual$9}, box E^?]]^):
-   |  box Future[box T^?]^{fr, contextual$9, contextual$9} leaks into outer capture set of type parameter T of method make in object Result
+   |local reference contextual$9 from (using contextual$9: boundary.Label[Result[box Future[box T^?]^{fr, contextual$9}, box E^?]]^):
+   |  box Future[box T^?]^{fr, contextual$9} leaks into outer capture set of type parameter T of method make in object Result
diff --git a/tests/neg-custom-args/captures/i21614.check b/tests/neg-custom-args/captures/i21614.check
index 14b468db4c8e..5e386fb3cb20 100644
--- a/tests/neg-custom-args/captures/i21614.check
+++ b/tests/neg-custom-args/captures/i21614.check
@@ -6,12 +6,20 @@
   |
   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i21614.scala:12:12 ---------------------------------------
-12 |  files.map(new Logger(_)) // error, Q: can we improve the error message?
+12 |  files.map(new Logger(_)) // error, Q: can we improve the error message? // error
    |            ^^^^^^^^^^^^^
-   |            Found:    Logger{val f: (_$1 : File^{files*})}^
-   |            Required: Logger{val f: File^?}^?
+   |           Found:    (_$1: box File^{files*}) ->{files*} (ex$4: caps.Exists) -> Logger{val f: File^{_$1}}^{ex$4}
+   |           Required: (_$1: box File^{files*}) -><fluid> box Logger{val f: File^?}^{ex$4, ex$4²}
    |
-   |            Note that the universal capability `cap`
-   |            cannot be included in capture set ?
+   |           where:    ex$4  is a reference to a value parameter
+   |                     ex$4² is a reference to a value parameter
+   |
+   |
+   |           Note that the universal capability `cap`
+   |           cannot be included in capture set ?
    |
    | longer explanation available when compiling with `-explain`
+-- Error: tests/neg-custom-args/captures/i21614.scala:12:8 -------------------------------------------------------------
+12 |  files.map(new Logger(_)) // error, Q: can we improve the error message? // error
+   |  ^^^^^^^^^
+   |  escaping local reference ex$4.type
diff --git a/tests/neg-custom-args/captures/i21614.scala b/tests/neg-custom-args/captures/i21614.scala
index 69aef446e9e2..6a1917656ebb 100644
--- a/tests/neg-custom-args/captures/i21614.scala
+++ b/tests/neg-custom-args/captures/i21614.scala
@@ -9,4 +9,4 @@ def mkLoggers1[F <: File^](@use files: List[F]): List[Logger^] =
   files.map((f: F) => new Logger(f)) // error, Q: can we make this pass (see #19076)?
 
 def mkLoggers2(@use files: List[File^]): List[Logger^] =
-  files.map(new Logger(_)) // error, Q: can we improve the error message?
+  files.map(new Logger(_)) // error, Q: can we improve the error message? // error
diff --git a/tests/neg-custom-args/captures/levels.check b/tests/neg-custom-args/captures/levels.check
index ddfa7c051211..2dae3ec3bbc6 100644
--- a/tests/neg-custom-args/captures/levels.check
+++ b/tests/neg-custom-args/captures/levels.check
@@ -5,10 +5,13 @@
    |          that type captures the root capability `cap`.
    |          This is often caused by a local capability in an argument of constructor Ref
    |          leaking as part of its result.
--- Error: tests/neg-custom-args/captures/levels.scala:24:11 ------------------------------------------------------------
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/levels.scala:24:11 ---------------------------------------
 24 |    r.setV(g) // error
    |           ^
-   |           reference (cap3 : CC^) is not included in the allowed capture set ? of value r
+   |           Found:    box (x: String) ->{cap3} String
+   |           Required: box (x$0: String) ->? String
    |
    |           Note that reference (cap3 : CC^), defined in method scope
    |           cannot be included in outer capture set ? of value r
+   |
+   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/vars-simple.check b/tests/neg-custom-args/captures/vars-simple.check
index e9671f775c22..2ef301b6ec1f 100644
--- a/tests/neg-custom-args/captures/vars-simple.check
+++ b/tests/neg-custom-args/captures/vars-simple.check
@@ -8,11 +8,13 @@
    |         since at least one of their capture sets contains the root capability `cap`
    |
    | longer explanation available when compiling with `-explain`
--- Error: tests/neg-custom-args/captures/vars-simple.scala:16:8 --------------------------------------------------------
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/vars-simple.scala:16:8 -----------------------------------
 16 |    a = g  // error
    |        ^
-   |        reference (cap3 : Cap) is not included in the allowed capture set {cap1, cap2}
-   |        of an enclosing function literal with expected type box String ->{cap1, cap2} String
+   |        Found:    box (x: String) ->{cap3} String
+   |        Required: box (x: String) ->{cap1, cap2} String
+   |
+   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/vars-simple.scala:17:12 ----------------------------------
 17 |    b = List(g) // error
    |        ^^^^^^^
diff --git a/tests/neg-custom-args/captures/vars.check b/tests/neg-custom-args/captures/vars.check
index 0d3c2e0f2e11..e4b1e71a2000 100644
--- a/tests/neg-custom-args/captures/vars.check
+++ b/tests/neg-custom-args/captures/vars.check
@@ -5,13 +5,16 @@
    |
    |             Note that reference (cap3 : Cap), defined in method scope
    |             cannot be included in outer capture set {cap1} of variable a
--- Error: tests/neg-custom-args/captures/vars.scala:25:8 ---------------------------------------------------------------
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/vars.scala:25:8 ------------------------------------------
 25 |    a = g      // error
    |        ^
-   |        reference (cap3 : Cap) is not included in the allowed capture set {cap1} of variable a
+   |        Found:    (x: String) ->{cap3} String
+   |        Required: (x$0: String) ->{cap1} String
    |
    |        Note that reference (cap3 : Cap), defined in method scope
    |        cannot be included in outer capture set {cap1} of variable a
+   |
+   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/vars.scala:27:12 -----------------------------------------
 27 |    b = List(g) // error
    |        ^^^^^^^

From 4226a337ab2406989633385088faf0a78ab08627 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Thu, 31 Oct 2024 18:30:38 +0100
Subject: [PATCH 209/306] Disable reach capabilities in nested closures
 appearing without @use

With our current @use scheme, this is unsound. We leave the possibility to re-enable
as a Config option which is disabled by default and comes with a warning that enabling
it would be unsound.
---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  | 10 ++++++---
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 16 ++++++++------
 .../captures/method-uses.scala                |  6 ++---
 .../captures/unsound-reach-5.scala            | 22 +++++++++++++++++++
 4 files changed, 41 insertions(+), 13 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/unsound-reach-5.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index 31ddfcc93bbc..6f7c6df19e84 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -28,12 +28,16 @@ object ccConfig:
   inline val allowUnsoundMaps = false
 
   /** If enabled, use a special path in recheckClosure for closures
-   *  that are eta expansions. This can improve some error messages but
-   *  currently leads to unsoundess for handling reach capabilities.
-   *  TODO: The unsoundness needs followin up.
+   *  that are eta expansions. This can improve some error messages.
    */
   inline val handleEtaExpansionsSpecially = true
 
+  /** Don't require @use for reach capabilities that are accessed
+   *  only in a nested closure. This is unsound without additional
+   *  mitigation measures, as shown by unsound-reach-5.scala.
+   */
+  inline val deferredReaches = false
+
   /** If true, use existential capture set variables */
   def useExistentials(using Context) =
     Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.5`)
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 5e4afe542922..05256ee515f2 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -824,13 +824,15 @@ class CheckCaptures extends Recheck, SymTransformer:
       if Synthetics.isExcluded(sym) then sym.info
       else
         // If rhs ends in a closure or anonymous class, the corresponding symbol
-        def nestedClosure(rhs: Tree)(using Context): Symbol = rhs match
-          case Closure(_, meth, _) => meth.symbol
-          case Apply(fn, _) if fn.symbol.isConstructor && fn.symbol.owner.isAnonymousClass => fn.symbol.owner
-          case Block(_, expr) => nestedClosure(expr)
-          case Inlined(_, _, expansion) => nestedClosure(expansion)
-          case Typed(expr, _) => nestedClosure(expr)
-          case _ => NoSymbol
+        def nestedClosure(rhs: Tree)(using Context): Symbol =
+          if !ccConfig.deferredReaches then NoSymbol
+          else rhs match
+            case Closure(_, meth, _) => meth.symbol
+            case Apply(fn, _) if fn.symbol.isConstructor && fn.symbol.owner.isAnonymousClass => fn.symbol.owner
+            case Block(_, expr) => nestedClosure(expr)
+            case Inlined(_, _, expansion) => nestedClosure(expansion)
+            case Typed(expr, _) => nestedClosure(expr)
+            case _ => NoSymbol
 
         val saved = curEnv
         val localSet = capturedVars(sym)
diff --git a/tests/neg-custom-args/captures/method-uses.scala b/tests/neg-custom-args/captures/method-uses.scala
index 4dad7119a8e4..69acef6a99a8 100644
--- a/tests/neg-custom-args/captures/method-uses.scala
+++ b/tests/neg-custom-args/captures/method-uses.scala
@@ -18,12 +18,12 @@ def test2(xs: List[() => Unit]) =
   ()
 
 def test3(xs: List[() => Unit]): () ->{xs*} Unit = () =>
-  println(xs.head)  // ok
+  println(xs.head)  // error, ok under deferredReaches
 
-  def test4(xs: List[() => Unit]) = () => xs.head // ok
+  def test4(xs: List[() => Unit]) = () => xs.head // error, ok under deferredReaches
 
   def test5(xs: List[() => Unit]) = new:
-    println(xs.head) // ok
+    println(xs.head) // error, ok under deferredReaches
 
   def test6(xs: List[() => Unit]) =
     val x= new { println(xs.head) } // error
diff --git a/tests/neg-custom-args/captures/unsound-reach-5.scala b/tests/neg-custom-args/captures/unsound-reach-5.scala
new file mode 100644
index 000000000000..806de5093ecd
--- /dev/null
+++ b/tests/neg-custom-args/captures/unsound-reach-5.scala
@@ -0,0 +1,22 @@
+class IO
+
+def f(xs: List[() => Unit]): () ->{xs*} Unit = () =>
+  println(xs.head) // error
+
+def test(io: IO^)(ys: List[() ->{io} Unit]) =
+  val x = () =>
+    val z = f(ys)
+    z()
+  val _: () -> Unit = x // !!! ys* gets lost
+  ()
+
+def test(io: IO^) =
+  def ys: List[() ->{io} Unit] = ???
+  val x = () =>
+    val z = f(ys)
+    z()
+  val _: () -> Unit = x // !!! io gets lost
+  ()
+
+
+

From 8f8a15fae612a45e4dddf06704c79d39686f3154 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Fri, 1 Nov 2024 14:05:00 +0100
Subject: [PATCH 210/306] Go back to sealed checking

Check that type parameters of methods and parent traits don't get instantiated
with types containing a `cap` anywhere in covariant or invariant position.
---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  |  7 +--
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 58 ++++++++++++-------
 .../captures/box-adapt-cases.scala            |  2 +-
 .../neg-custom-args/captures/capt-test.scala  |  4 +-
 tests/neg-custom-args/captures/capt1.check    | 20 +++----
 tests/neg-custom-args/captures/capt1.scala    |  4 +-
 .../captures/effect-swaps-explicit.scala      |  4 +-
 .../captures/effect-swaps.check               |  5 ++
 .../captures/effect-swaps.scala               |  2 +-
 tests/neg-custom-args/captures/filevar.scala  |  4 +-
 tests/neg-custom-args/captures/hk-param.scala | 16 +++++
 tests/neg-custom-args/captures/i15749.scala   |  2 +
 tests/neg-custom-args/captures/i15772.check   |  8 +--
 tests/neg-custom-args/captures/i15922.scala   |  4 +-
 .../captures/i15923-cases.scala               |  7 ---
 tests/neg-custom-args/captures/i16114.check   | 50 +++++++---------
 tests/neg-custom-args/captures/i16114.scala   |  4 +-
 .../captures/i19330-alt2.scala                |  4 +-
 tests/neg-custom-args/captures/i19330.scala   |  4 +-
 tests/neg-custom-args/captures/i21401.check   | 35 +++++++----
 tests/neg-custom-args/captures/i21401.scala   |  8 +--
 tests/neg-custom-args/captures/i21614.check   | 18 ++----
 tests/neg-custom-args/captures/i21614.scala   |  2 +-
 tests/neg-custom-args/captures/i21646.scala   |  2 +-
 .../captures/lazylists-exceptions.check       |  5 +-
 tests/neg-custom-args/captures/levels.check   | 16 +++--
 tests/neg-custom-args/captures/levels.scala   |  2 -
 .../neg-custom-args/captures/outer-var.check  | 30 +++++++---
 .../neg-custom-args/captures/outer-var.scala  |  4 +-
 tests/neg-custom-args/captures/reaches.check  | 31 +++++-----
 tests/neg-custom-args/captures/reaches.scala  |  8 +--
 tests/neg-custom-args/captures/real-try.check |  8 +--
 tests/neg-custom-args/captures/real-try.scala |  4 +-
 tests/neg-custom-args/captures/try.check      | 14 ++---
 tests/neg-custom-args/captures/try.scala      |  4 +-
 tests/neg-custom-args/captures/unbox.scala    |  2 +-
 .../captures/unsound-reach-2.scala            |  4 +-
 .../captures/unsound-reach-3.scala            |  6 +-
 .../captures/unsound-reach-4.check            |  5 ++
 .../captures/unsound-reach-4.scala            |  6 +-
 .../captures/unsound-reach.check              | 23 ++++----
 .../captures/unsound-reach.scala              |  9 ++-
 .../captures/vars-simple.check                |  9 +--
 tests/neg-custom-args/captures/vars.scala     |  4 +-
 .../captures/widen-reach.check                | 12 ++--
 .../captures/widen-reach.scala                |  4 +-
 tests/pos-custom-args/captures/hk-param.scala |  2 +
 .../captures/i15923-cases.scala               |  4 ++
 tests/pos-custom-args/captures/levels.scala   |  6 +-
 49 files changed, 268 insertions(+), 228 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/hk-param.scala
 delete mode 100644 tests/neg-custom-args/captures/i15923-cases.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index 6f7c6df19e84..97c774b593a6 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -45,12 +45,11 @@ object ccConfig:
   /** If true, use "sealed" as encapsulation mechanism, meaning that we
    *  check that type variable instantiations don't have `cap` in any of
    *  their capture sets. This is an alternative of the original restriction
-   *  that `cap` can't be boxed or unboxed. It is used in 3.3 and 3.4 but
-   *  dropped again in 3.5.
+   *  that `cap` can't be boxed or unboxed. It is dropped in 3.5 but used
+   *  again in 3.6.
    */
   def useSealed(using Context) =
-    Feature.sourceVersion.stable == SourceVersion.`3.3`
-    || Feature.sourceVersion.stable == SourceVersion.`3.4`
+    Feature.sourceVersion.stable != SourceVersion.`3.5`
 end ccConfig
 
 
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 05256ee515f2..cce5a7cd21dd 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -174,8 +174,7 @@ object CheckCaptures:
                 def part = if t eq tp then "" else i"the part $t of "
                 report.error(
                   em"""$what cannot $have $tp since
-                      |${part}that type captures the root capability `cap`.
-                      |$addendum""",
+                      |${part}that type captures the root capability `cap`.$addendum""",
                   pos)
             traverse(parent)
           case t =>
@@ -686,23 +685,34 @@ class CheckCaptures extends Recheck, SymTransformer:
       else ownType
     end instantiate
 
+    def disallowCapInTypeArgs(fn: Tree, sym: Symbol, args: List[Tree])(using Context): Unit =
+      def isExempt = sym.isTypeTestOrCast || sym == defn.Compiletime_erasedValue
+      if ccConfig.useSealed && !isExempt then
+        val paramNames = atPhase(thisPhase.prev):
+          fn.tpe.widenDealias match
+            case tl: TypeLambda => tl.paramNames
+            case ref: AppliedType if ref.typeSymbol.isClass => ref.typeSymbol.typeParams.map(_.name)
+            case t =>
+              println(i"parent type: $t")
+              args.map(_ => EmptyTypeName)
+        for case (arg: TypeTree, pname) <- args.lazyZip(paramNames) do
+          def where = if sym.exists then i" in an argument of $sym" else ""
+          val (addendum, pos) =
+            if arg.isInferred
+            then ("\nThis is often caused by a local capability$where\nleaking as part of its result.", fn.srcPos)
+            else if arg.span.exists then ("", arg.srcPos)
+            else ("", fn.srcPos)
+          disallowRootCapabilitiesIn(arg.knownType, NoSymbol,
+            i"Type variable $pname of $sym", "be instantiated to", addendum, pos)
+    end disallowCapInTypeArgs
+
     override def recheckTypeApply(tree: TypeApply, pt: Type)(using Context): Type =
-      val meth = tree.symbol
-      if ccConfig.useSealed then
-        val TypeApply(fn, args) = tree
-        val polyType = atPhase(thisPhase.prev):
-          fn.tpe.widen.asInstanceOf[TypeLambda]
-        def isExempt(sym: Symbol) =
-          sym.isTypeTestOrCast || sym == defn.Compiletime_erasedValue
-        for case (arg: TypeTree, formal, pname) <- args.lazyZip(polyType.paramRefs).lazyZip((polyType.paramNames)) do
-          if !isExempt(meth) then
-            def where = if meth.exists then i" in an argument of $meth" else ""
-            disallowRootCapabilitiesIn(arg.knownType, NoSymbol,
-              i"Sealed type variable $pname", "be instantiated to",
-              i"This is often caused by a local capability$where\nleaking as part of its result.",
-              tree.srcPos)
+      val meth = tree.fun match
+        case fun @ Select(qual, nme.apply) => qual.symbol.orElse(fun.symbol)
+        case fun => fun.symbol
+      disallowCapInTypeArgs(tree.fun, meth, tree.args)
       val res = Existential.toCap(super.recheckTypeApply(tree, pt))
-      includeCallCaptures(meth, res, tree.srcPos)
+      includeCallCaptures(tree.symbol, res, tree.srcPos)
       checkContains(tree)
       res
     end recheckTypeApply
@@ -806,7 +816,7 @@ class CheckCaptures extends Recheck, SymTransformer:
                       case _ => ""
                     s"an anonymous function$location"
                   else encl.show
-                (NoSymbol, i"\nNote that $sym does not count as local since it is captured by $enclStr")
+                (NoSymbol, i"\n\nNote that $sym does not count as local since it is captured by $enclStr")
               case _ =>
                 (sym, "")
             disallowRootCapabilitiesIn(
@@ -927,6 +937,11 @@ class CheckCaptures extends Recheck, SymTransformer:
           checkSubset(thisSet,
             CaptureSet.empty.withDescription(i"of pure base class $pureBase"),
             selfType.srcPos, cs1description = " captured by this self type")
+        for case tpt: TypeTree <- impl.parents do
+          tpt.tpe match
+            case AppliedType(fn, args) =>
+              disallowCapInTypeArgs(tpt, fn.typeSymbol, args.map(TypeTree(_)))
+            case _ =>
         inNestedLevelUnless(cls.is(Module)):
           super.recheckClassDef(tree, impl, cls)
       finally
@@ -950,8 +965,8 @@ class CheckCaptures extends Recheck, SymTransformer:
       val tp = super.recheckTry(tree, pt)
       if ccConfig.useSealed && Feature.enabled(Feature.saferExceptions) then
         disallowRootCapabilitiesIn(tp, ctx.owner,
-          "result of `try`", "have type",
-          "This is often caused by a locally generated exception capability leaking as part of its result.",
+          "The result of `try`", "have type",
+          "\nThis is often caused by a locally generated exception capability leaking as part of its result.",
           tree.srcPos)
       tp
 
@@ -1592,8 +1607,7 @@ class CheckCaptures extends Recheck, SymTransformer:
                 && !arg.typeSymbol.name.is(WildcardParamName)
               then
                 CheckCaptures.disallowRootCapabilitiesIn(arg, NoSymbol,
-                  "Array", "have element type",
-                  "Since arrays are mutable, they have to be treated like variables,\nso their element type must be sealed.",
+                  "Array", "have element type", "",
                   pos)
               traverseChildren(t)
             case defn.RefinedFunctionOf(rinfo: MethodType) =>
diff --git a/tests/neg-custom-args/captures/box-adapt-cases.scala b/tests/neg-custom-args/captures/box-adapt-cases.scala
index 681d699842ed..d9ec0f80a548 100644
--- a/tests/neg-custom-args/captures/box-adapt-cases.scala
+++ b/tests/neg-custom-args/captures/box-adapt-cases.scala
@@ -4,7 +4,7 @@ def test1(): Unit = {
   type Id[X] = [T] -> (op: X => T) -> T
 
   val x: Id[Cap^] = ???
-  x(cap => cap.use())  // error, OK under sealed
+  x(cap => cap.use())
 }
 
 def test2(io: Cap^): Unit = {
diff --git a/tests/neg-custom-args/captures/capt-test.scala b/tests/neg-custom-args/captures/capt-test.scala
index b202a14d0940..80ee1aba84e1 100644
--- a/tests/neg-custom-args/captures/capt-test.scala
+++ b/tests/neg-custom-args/captures/capt-test.scala
@@ -20,8 +20,8 @@ def handle[E <: Exception,  R <: Top](op: (CT[E] @retains(caps.cap)) => R)(handl
   catch case ex: E => handler(ex)
 
 def test: Unit =
-  val b = handle[Exception, () => Nothing] {
+  val b = handle[Exception, () => Nothing] { // error
     (x: CanThrow[Exception]) => () => raise(new Exception)(using x)
-  } { // error
+  } {
     (ex: Exception) => ???
   }
diff --git a/tests/neg-custom-args/captures/capt1.check b/tests/neg-custom-args/captures/capt1.check
index 3d0ed538b2e5..94103799d698 100644
--- a/tests/neg-custom-args/captures/capt1.check
+++ b/tests/neg-custom-args/captures/capt1.check
@@ -33,22 +33,18 @@
 29 |    def m() = if x == null then y else y
    |
    | longer explanation available when compiling with `-explain`
--- Error: tests/neg-custom-args/captures/capt1.scala:34:12 -------------------------------------------------------------
+-- Error: tests/neg-custom-args/captures/capt1.scala:34:16 -------------------------------------------------------------
 34 |  val z2 = h[() -> Cap](() => x) // error // error
-   |           ^^^^^^^^^^^^
-   |           Sealed type variable X cannot be instantiated to () -> box C^ since
-   |           the part box C^ of that type captures the root capability `cap`.
-   |           This is often caused by a local capability in an argument of method h
-   |           leaking as part of its result.
+   |             ^^^^^^^^^
+   |             Type variable X of method h cannot be instantiated to () -> box C^ since
+   |             the part box C^ of that type captures the root capability `cap`.
 -- Error: tests/neg-custom-args/captures/capt1.scala:34:30 -------------------------------------------------------------
 34 |  val z2 = h[() -> Cap](() => x) // error // error
    |                              ^
    |                            (x : C^) cannot be referenced here; it is not included in the allowed capture set {}
    |                            of an enclosing function literal with expected type () -> box C^
--- Error: tests/neg-custom-args/captures/capt1.scala:36:12 -------------------------------------------------------------
+-- Error: tests/neg-custom-args/captures/capt1.scala:36:13 -------------------------------------------------------------
 36 |  val z3 = h[(() -> Cap) @retains(x)](() => x)(() => C())  // error
-   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |           Sealed type variable X cannot be instantiated to box () ->{x} Cap since
-   |           the part Cap of that type captures the root capability `cap`.
-   |           This is often caused by a local capability in an argument of method h
-   |           leaking as part of its result.
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+   |             Type variable X of method h cannot be instantiated to box () ->{x} Cap since
+   |             the part Cap of that type captures the root capability `cap`.
diff --git a/tests/neg-custom-args/captures/capt1.scala b/tests/neg-custom-args/captures/capt1.scala
index cad0bad4ba56..8da7e633ca51 100644
--- a/tests/neg-custom-args/captures/capt1.scala
+++ b/tests/neg-custom-args/captures/capt1.scala
@@ -1,5 +1,5 @@
-//> using options -source 3.4
-// (to make sure we use the sealed policy)
+
+
 import annotation.retains
 class C
 def f(x: C @retains(caps.cap), y: C): () -> C =
diff --git a/tests/neg-custom-args/captures/effect-swaps-explicit.scala b/tests/neg-custom-args/captures/effect-swaps-explicit.scala
index 7474e1711b34..e440271ccf88 100644
--- a/tests/neg-custom-args/captures/effect-swaps-explicit.scala
+++ b/tests/neg-custom-args/captures/effect-swaps-explicit.scala
@@ -1,5 +1,5 @@
-//> using options -source 3.4
-// (to make sure we use the sealed policy)
+
+
 object boundary:
 
   final class Label[-T] // extends caps.Capability
diff --git a/tests/neg-custom-args/captures/effect-swaps.check b/tests/neg-custom-args/captures/effect-swaps.check
index ef5a95d333bf..b74c165fd6b6 100644
--- a/tests/neg-custom-args/captures/effect-swaps.check
+++ b/tests/neg-custom-args/captures/effect-swaps.check
@@ -22,3 +22,8 @@
 73 |            fr.await.ok
    |
    | longer explanation available when compiling with `-explain`
+-- Error: tests/neg-custom-args/captures/effect-swaps.scala:66:15 ------------------------------------------------------
+66 |        Result.make: // error: local reference leaks
+   |        ^^^^^^^^^^^
+   |local reference contextual$9 from (using contextual$9: boundary.Label[Result[box Future[box T^?]^{fr, contextual$9}, box E^?]]^):
+   |  box Future[box T^?]^{fr, contextual$9} leaks into outer capture set of type parameter T of method make in object Result
diff --git a/tests/neg-custom-args/captures/effect-swaps.scala b/tests/neg-custom-args/captures/effect-swaps.scala
index 4bafd6421af3..99c781b963c5 100644
--- a/tests/neg-custom-args/captures/effect-swaps.scala
+++ b/tests/neg-custom-args/captures/effect-swaps.scala
@@ -63,7 +63,7 @@ def test[T, E](using Async) =
           fr.await.ok
 
     def fail4[T, E](fr: Future[Result[T, E]]^) =
-        Result.make: // should be errorm but inders Result[Any, Any]
+        Result.make: // error: local reference leaks
           Future: fut ?=>
             fr.await.ok
 
diff --git a/tests/neg-custom-args/captures/filevar.scala b/tests/neg-custom-args/captures/filevar.scala
index e54f161ef124..5b83f1d29380 100644
--- a/tests/neg-custom-args/captures/filevar.scala
+++ b/tests/neg-custom-args/captures/filevar.scala
@@ -5,8 +5,8 @@ class File:
   def write(x: String): Unit = ???
 
 class Service:
-  var file: File^ = uninitialized  // OK, was error under sealed
-  def log = file.write("log") // error, was OK under sealed
+  var file: File^ = uninitialized  // error, was OK under unsealed
+  def log = file.write("log") // OK, was error under unsealed
 
 def withFile[T](op: (l: caps.Capability) ?-> (f: File^{l}) => T): T =
   op(using caps.cap)(new File)
diff --git a/tests/neg-custom-args/captures/hk-param.scala b/tests/neg-custom-args/captures/hk-param.scala
new file mode 100644
index 000000000000..bfd4f82a0697
--- /dev/null
+++ b/tests/neg-custom-args/captures/hk-param.scala
@@ -0,0 +1,16 @@
+/** Concrete collection type: View */
+trait View[+A] extends Itable[A], ILike[A, [X] =>> View[X]^]: // error
+  override def fromIterable[B](c: Itable[B]^): View[B]^{c} = ???
+
+trait IPolyTransforms[+A, +C[A]] extends Any:
+  def fromIterable[B](coll: Itable[B]^): C[B]
+
+trait ILike[+A, +C[X] <: Itable[X]^] extends IPolyTransforms[A, C]
+
+/** Base trait for generic collections */
+trait Itable[+A] extends ItableOnce[A] with ILike[A, Itable^] // error
+
+/** Iterator can be used only once */
+trait ItableOnce[+A] {
+  def iterator: Iterator[A]^{this}
+}
diff --git a/tests/neg-custom-args/captures/i15749.scala b/tests/neg-custom-args/captures/i15749.scala
index c5b59042085a..9a4e8b0b81ae 100644
--- a/tests/neg-custom-args/captures/i15749.scala
+++ b/tests/neg-custom-args/captures/i15749.scala
@@ -1,3 +1,5 @@
+//> using options -source 3.5
+// (to make sure we use the unsealed policy)
 class Unit
 object unit extends Unit
 
diff --git a/tests/neg-custom-args/captures/i15772.check b/tests/neg-custom-args/captures/i15772.check
index 58582423b101..0f8f0bf6eac5 100644
--- a/tests/neg-custom-args/captures/i15772.check
+++ b/tests/neg-custom-args/captures/i15772.check
@@ -25,11 +25,11 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:33:34 ---------------------------------------
 33 |  val boxed2 : Observe[C]^ = box2(c) // error
    |                                  ^
-   |                                  Found:    C^
-   |                                  Required: box C{val arg: C^?}^
+   |                                  Found:    box C^
+   |                                  Required: box C{val arg: C^?}^?
    |
-   |                                  Note that C^ cannot be box-converted to box C{val arg: C^?}^
-   |                                  since at least one of their capture sets contains the root capability `cap`
+   |                                  Note that the universal capability `cap`
+   |                                  cannot be included in capture set ?
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:44:2 ----------------------------------------
diff --git a/tests/neg-custom-args/captures/i15922.scala b/tests/neg-custom-args/captures/i15922.scala
index 89bf91493fcd..848a22fe5341 100644
--- a/tests/neg-custom-args/captures/i15922.scala
+++ b/tests/neg-custom-args/captures/i15922.scala
@@ -1,5 +1,5 @@
-//> using options -source 3.4
-// (to force sealed encapsulation checking)
+
+
 trait Cap { def use(): Int }
 type Id[X] = [T] -> (op: X => T) -> T
 def mkId[X](x: X): Id[X] = [T] => (op: X => T) => op(x)
diff --git a/tests/neg-custom-args/captures/i15923-cases.scala b/tests/neg-custom-args/captures/i15923-cases.scala
deleted file mode 100644
index 83cfa554e8b9..000000000000
--- a/tests/neg-custom-args/captures/i15923-cases.scala
+++ /dev/null
@@ -1,7 +0,0 @@
-trait Cap { def use(): Int }
-type Id[X] = [T] -> (op: X => T) -> T
-def mkId[X](x: X): Id[X] = [T] => (op: X => T) => op(x)
-
-def foo(x: Id[Cap^]) = {
-  x(_.use())  // error, was OK under sealed policy
-}
diff --git a/tests/neg-custom-args/captures/i16114.check b/tests/neg-custom-args/captures/i16114.check
index 6d81d8d63747..3b9fbd40493f 100644
--- a/tests/neg-custom-args/captures/i16114.check
+++ b/tests/neg-custom-args/captures/i16114.check
@@ -1,48 +1,38 @@
--- Error: tests/neg-custom-args/captures/i16114.scala:18:12 ------------------------------------------------------------
+-- Error: tests/neg-custom-args/captures/i16114.scala:18:13 ------------------------------------------------------------
 18 |      expect[Cap^] {  // error
-   |      ^^^^^^^^^^^^
-   |      Sealed type variable T cannot be instantiated to box Cap^ since
-   |      that type captures the root capability `cap`.
-   |      This is often caused by a local capability in an argument of method expect
-   |      leaking as part of its result.
+   |             ^^^^
+   |             Type variable T of method expect cannot be instantiated to box Cap^ since
+   |             that type captures the root capability `cap`.
 -- Error: tests/neg-custom-args/captures/i16114.scala:20:8 -------------------------------------------------------------
 20 |        fs  // error (limitation)
    |        ^^
    |        (fs : Cap^) cannot be referenced here; it is not included in the allowed capture set {io}
    |        of an enclosing function literal with expected type Unit ->{io} Unit
--- Error: tests/neg-custom-args/captures/i16114.scala:24:12 ------------------------------------------------------------
+-- Error: tests/neg-custom-args/captures/i16114.scala:24:13 ------------------------------------------------------------
 24 |      expect[Cap^] { // error
-   |      ^^^^^^^^^^^^
-   |      Sealed type variable T cannot be instantiated to box Cap^ since
-   |      that type captures the root capability `cap`.
-   |      This is often caused by a local capability in an argument of method expect
-   |      leaking as part of its result.
+   |             ^^^^
+   |             Type variable T of method expect cannot be instantiated to box Cap^ since
+   |             that type captures the root capability `cap`.
 -- Error: tests/neg-custom-args/captures/i16114.scala:26:8 -------------------------------------------------------------
 26 |        io  // error (limitation)
    |        ^^
    |        (io : Cap^) cannot be referenced here; it is not included in the allowed capture set {fs}
    |        of an enclosing function literal with expected type Unit ->{fs} Unit
--- Error: tests/neg-custom-args/captures/i16114.scala:30:12 ------------------------------------------------------------
+-- Error: tests/neg-custom-args/captures/i16114.scala:30:13 ------------------------------------------------------------
 30 |      expect[Cap^] {  // error
-   |      ^^^^^^^^^^^^
-   |      Sealed type variable T cannot be instantiated to box Cap^ since
-   |      that type captures the root capability `cap`.
-   |      This is often caused by a local capability in an argument of method expect
-   |      leaking as part of its result.
--- Error: tests/neg-custom-args/captures/i16114.scala:36:12 ------------------------------------------------------------
+   |             ^^^^
+   |             Type variable T of method expect cannot be instantiated to box Cap^ since
+   |             that type captures the root capability `cap`.
+-- Error: tests/neg-custom-args/captures/i16114.scala:36:13 ------------------------------------------------------------
 36 |      expect[Cap^](io) // error
-   |      ^^^^^^^^^^^^
-   |      Sealed type variable T cannot be instantiated to box Cap^ since
-   |      that type captures the root capability `cap`.
-   |      This is often caused by a local capability in an argument of method expect
-   |      leaking as part of its result.
--- Error: tests/neg-custom-args/captures/i16114.scala:39:12 ------------------------------------------------------------
+   |             ^^^^
+   |             Type variable T of method expect cannot be instantiated to box Cap^ since
+   |             that type captures the root capability `cap`.
+-- Error: tests/neg-custom-args/captures/i16114.scala:39:13 ------------------------------------------------------------
 39 |      expect[Cap^] { // error
-   |      ^^^^^^^^^^^^
-   |      Sealed type variable T cannot be instantiated to box Cap^ since
-   |      that type captures the root capability `cap`.
-   |      This is often caused by a local capability in an argument of method expect
-   |      leaking as part of its result.
+   |             ^^^^
+   |             Type variable T of method expect cannot be instantiated to box Cap^ since
+   |             that type captures the root capability `cap`.
 -- Error: tests/neg-custom-args/captures/i16114.scala:40:8 -------------------------------------------------------------
 40 |        io.use()    // error
    |        ^^
diff --git a/tests/neg-custom-args/captures/i16114.scala b/tests/neg-custom-args/captures/i16114.scala
index ec04fe9c9827..801ea3b11a3d 100644
--- a/tests/neg-custom-args/captures/i16114.scala
+++ b/tests/neg-custom-args/captures/i16114.scala
@@ -1,5 +1,5 @@
-//> using options -source 3.4
-// (to make sure we use the sealed policy)
+
+
 trait Cap { def use(): Int; def close(): Unit }
 def mkCap(): Cap^ = ???
 
diff --git a/tests/neg-custom-args/captures/i19330-alt2.scala b/tests/neg-custom-args/captures/i19330-alt2.scala
index 86634b45dbe3..3e52e3c65634 100644
--- a/tests/neg-custom-args/captures/i19330-alt2.scala
+++ b/tests/neg-custom-args/captures/i19330-alt2.scala
@@ -1,5 +1,5 @@
-//> using options -source 3.4
-// (to make sure we use the sealed policy)
+
+
 import language.experimental.captureChecking
 
 trait Logger
diff --git a/tests/neg-custom-args/captures/i19330.scala b/tests/neg-custom-args/captures/i19330.scala
index 5fbdc00db311..715b670860cd 100644
--- a/tests/neg-custom-args/captures/i19330.scala
+++ b/tests/neg-custom-args/captures/i19330.scala
@@ -1,5 +1,5 @@
-//> using options -source 3.4
-// (to force sealed encapsulation checking)
+
+
 import language.experimental.captureChecking
 
 trait Logger
diff --git a/tests/neg-custom-args/captures/i21401.check b/tests/neg-custom-args/captures/i21401.check
index e204540358ce..679c451949bd 100644
--- a/tests/neg-custom-args/captures/i21401.check
+++ b/tests/neg-custom-args/captures/i21401.check
@@ -1,13 +1,28 @@
--- Error: tests/neg-custom-args/captures/i21401.scala:15:22 ------------------------------------------------------------
-15 |  val a = usingIO[IO^](x => x) // error: The expression's type IO^ is not allowed to capture the root capability `cap`
-   |          ^^^^^^^^^^^^^^^^^^^^
-   |          The expression's type box IO^ is not allowed to capture the root capability `cap`.
-   |          This usually means that a capability persists longer than its allowed lifetime.
--- Error: tests/neg-custom-args/captures/i21401.scala:16:70 ------------------------------------------------------------
-16 |  val leaked: [R, X <: Boxed[IO^] -> R] -> (op: X) -> R = usingIO[Res](mkRes) // error: The expression's type Res is not allowed to capture the root capability `cap` in its part box IO^
-   |                                                          ^^^^^^^^^^^^^^^^^^^
-   |              The expression's type Res is not allowed to capture the root capability `cap` in its part box IO^.
-   |              This usually means that a capability persists longer than its allowed lifetime.
+-- Error: tests/neg-custom-args/captures/i21401.scala:13:14 ------------------------------------------------------------
+13 |    op1(Boxed[IO^](x)) // error
+   |              ^^^
+   |              Type variable T of object Boxed cannot be instantiated to box IO^ since
+   |              that type captures the root capability `cap`.
+-- Error: tests/neg-custom-args/captures/i21401.scala:15:18 ------------------------------------------------------------
+15 |  val a = usingIO[IO^](x => x) // error
+   |                  ^^^
+   |                  Type variable R of method usingIO cannot be instantiated to box IO^ since
+   |                  that type captures the root capability `cap`.
+-- Error: tests/neg-custom-args/captures/i21401.scala:16:66 ------------------------------------------------------------
+16 |  val leaked: [R, X <: Boxed[IO^] -> R] -> (op: X) -> R = usingIO[Res](mkRes) // error
+   |                                                                  ^^^
+   |                                           Type variable R of method usingIO cannot be instantiated to Res since
+   |                                           the part box IO^ of that type captures the root capability `cap`.
+-- Error: tests/neg-custom-args/captures/i21401.scala:17:29 ------------------------------------------------------------
+17 |  val x: Boxed[IO^] = leaked[Boxed[IO^], Boxed[IO^] -> Boxed[IO^]](x => x) // error // error
+   |                             ^^^^^^^^^^
+   |                             Type variable R of value leaked cannot be instantiated to Boxed[box IO^] since
+   |                             the part box IO^ of that type captures the root capability `cap`.
+-- Error: tests/neg-custom-args/captures/i21401.scala:17:52 ------------------------------------------------------------
+17 |  val x: Boxed[IO^] = leaked[Boxed[IO^], Boxed[IO^] -> Boxed[IO^]](x => x) // error // error
+   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^
+   |Type variable X of value leaked cannot be instantiated to Boxed[box IO^] -> (ex$18: caps.Exists) -> Boxed[box IO^{ex$18}] since
+   |the part box IO^{ex$18} of that type captures the root capability `cap`.
 -- Error: tests/neg-custom-args/captures/i21401.scala:18:21 ------------------------------------------------------------
 18 |  val y: IO^{x*} = x.unbox // error
    |                   ^^^^^^^
diff --git a/tests/neg-custom-args/captures/i21401.scala b/tests/neg-custom-args/captures/i21401.scala
index 8284c601cd5f..0b5479376a0a 100644
--- a/tests/neg-custom-args/captures/i21401.scala
+++ b/tests/neg-custom-args/captures/i21401.scala
@@ -10,10 +10,10 @@ type Res = [R, X <: Boxed[IO^] -> R] -> (op: X) -> R
 def mkRes(x: IO^): Res =
   [R, X <: Boxed[IO^] -> R] => (op: X) =>
     val op1: Boxed[IO^] -> R = op
-    op1(Boxed[IO^](x))
+    op1(Boxed[IO^](x)) // error
 def test2() =
-  val a = usingIO[IO^](x => x) // error: The expression's type IO^ is not allowed to capture the root capability `cap`
-  val leaked: [R, X <: Boxed[IO^] -> R] -> (op: X) -> R = usingIO[Res](mkRes) // error: The expression's type Res is not allowed to capture the root capability `cap` in its part box IO^
-  val x: Boxed[IO^] = leaked[Boxed[IO^], Boxed[IO^] -> Boxed[IO^]](x => x)
+  val a = usingIO[IO^](x => x) // error
+  val leaked: [R, X <: Boxed[IO^] -> R] -> (op: X) -> R = usingIO[Res](mkRes) // error
+  val x: Boxed[IO^] = leaked[Boxed[IO^], Boxed[IO^] -> Boxed[IO^]](x => x) // error // error
   val y: IO^{x*} = x.unbox // error
   y.println("boom")
diff --git a/tests/neg-custom-args/captures/i21614.check b/tests/neg-custom-args/captures/i21614.check
index 5e386fb3cb20..ced3ab7fd59a 100644
--- a/tests/neg-custom-args/captures/i21614.check
+++ b/tests/neg-custom-args/captures/i21614.check
@@ -6,20 +6,12 @@
   |
   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i21614.scala:12:12 ---------------------------------------
-12 |  files.map(new Logger(_)) // error, Q: can we improve the error message? // error
+12 |  files.map(new Logger(_)) // error, Q: can we improve the error message?
    |            ^^^^^^^^^^^^^
-   |           Found:    (_$1: box File^{files*}) ->{files*} (ex$4: caps.Exists) -> Logger{val f: File^{_$1}}^{ex$4}
-   |           Required: (_$1: box File^{files*}) -><fluid> box Logger{val f: File^?}^{ex$4, ex$4²}
+   |     Found:    (_$1: box File^{files*}) ->{files*} (ex$13: caps.Exists) -> box Logger{val f: File^{_$1}}^{ex$13}
+   |     Required: (_$1: box File^{files*}) -><fluid> box Logger{val f: File^?}^?
    |
-   |           where:    ex$4  is a reference to a value parameter
-   |                     ex$4² is a reference to a value parameter
-   |
-   |
-   |           Note that the universal capability `cap`
-   |           cannot be included in capture set ?
+   |     Note that the universal capability `cap`
+   |     cannot be included in capture set ?
    |
    | longer explanation available when compiling with `-explain`
--- Error: tests/neg-custom-args/captures/i21614.scala:12:8 -------------------------------------------------------------
-12 |  files.map(new Logger(_)) // error, Q: can we improve the error message? // error
-   |  ^^^^^^^^^
-   |  escaping local reference ex$4.type
diff --git a/tests/neg-custom-args/captures/i21614.scala b/tests/neg-custom-args/captures/i21614.scala
index 6a1917656ebb..69aef446e9e2 100644
--- a/tests/neg-custom-args/captures/i21614.scala
+++ b/tests/neg-custom-args/captures/i21614.scala
@@ -9,4 +9,4 @@ def mkLoggers1[F <: File^](@use files: List[F]): List[Logger^] =
   files.map((f: F) => new Logger(f)) // error, Q: can we make this pass (see #19076)?
 
 def mkLoggers2(@use files: List[File^]): List[Logger^] =
-  files.map(new Logger(_)) // error, Q: can we improve the error message? // error
+  files.map(new Logger(_)) // error, Q: can we improve the error message?
diff --git a/tests/neg-custom-args/captures/i21646.scala b/tests/neg-custom-args/captures/i21646.scala
index 42c493a9ea80..cf451ded3120 100644
--- a/tests/neg-custom-args/captures/i21646.scala
+++ b/tests/neg-custom-args/captures/i21646.scala
@@ -5,7 +5,7 @@ trait File extends Capability
 
 class Resource[T <: Capability](gen: T):
   def use[U](f: T => U): U =
-    f(gen) // error
+    f(gen) // OK, was error under unsealed
 
 @main def run =
   val myFile: File = ???
diff --git a/tests/neg-custom-args/captures/lazylists-exceptions.check b/tests/neg-custom-args/captures/lazylists-exceptions.check
index 4a8738118609..111719a81f07 100644
--- a/tests/neg-custom-args/captures/lazylists-exceptions.check
+++ b/tests/neg-custom-args/captures/lazylists-exceptions.check
@@ -1,8 +1,9 @@
 -- Error: tests/neg-custom-args/captures/lazylists-exceptions.scala:36:2 -----------------------------------------------
 36 |  try // error
    |  ^
-   |  The expression's type LazyList[Int]^ is not allowed to capture the root capability `cap`.
-   |  This usually means that a capability persists longer than its allowed lifetime.
+   |  The result of `try` cannot have type LazyList[Int]^ since
+   |  that type captures the root capability `cap`.
+   |  This is often caused by a locally generated exception capability leaking as part of its result.
 37 |    tabulate(10) { i =>
 38 |      if i > 9 then throw Ex1()
 39 |      i * i
diff --git a/tests/neg-custom-args/captures/levels.check b/tests/neg-custom-args/captures/levels.check
index 2dae3ec3bbc6..b99adefd4b2f 100644
--- a/tests/neg-custom-args/captures/levels.check
+++ b/tests/neg-custom-args/captures/levels.check
@@ -1,12 +1,10 @@
--- Error: tests/neg-custom-args/captures/levels.scala:19:13 ------------------------------------------------------------
-19 |  val _ = Ref[String => String]((x: String) => x) // error
-   |          ^^^^^^^^^^^^^^^^^^^^^
-   |          Sealed type variable T cannot be instantiated to box String => String since
-   |          that type captures the root capability `cap`.
-   |          This is often caused by a local capability in an argument of constructor Ref
-   |          leaking as part of its result.
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/levels.scala:24:11 ---------------------------------------
-24 |    r.setV(g) // error
+-- Error: tests/neg-custom-args/captures/levels.scala:17:21 ------------------------------------------------------------
+17 |  val _ = Ref[String => String]((x: String) => x) // error
+   |              ^^^^^^^^^^^^^^^^
+   |              Type variable T of constructor Ref cannot be instantiated to box String => String since
+   |              that type captures the root capability `cap`.
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/levels.scala:22:11 ---------------------------------------
+22 |    r.setV(g) // error
    |           ^
    |           Found:    box (x: String) ->{cap3} String
    |           Required: box (x$0: String) ->? String
diff --git a/tests/neg-custom-args/captures/levels.scala b/tests/neg-custom-args/captures/levels.scala
index 4709fd80d9b8..b28e87f03ef7 100644
--- a/tests/neg-custom-args/captures/levels.scala
+++ b/tests/neg-custom-args/captures/levels.scala
@@ -1,5 +1,3 @@
-//> using options -source 3.4
-// (to make sure we use the sealed policy)
 class CC
 
 def test1(cap1: CC^) =
diff --git a/tests/neg-custom-args/captures/outer-var.check b/tests/neg-custom-args/captures/outer-var.check
index 32351a179eab..72af842728a1 100644
--- a/tests/neg-custom-args/captures/outer-var.check
+++ b/tests/neg-custom-args/captures/outer-var.check
@@ -1,8 +1,8 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/outer-var.scala:11:8 -------------------------------------
 11 |    x = q           // error
    |        ^
-   |        Found:    box () ->{q} Unit
-   |        Required: box () ->{p, q²} Unit
+   |        Found:    (q : Proc)
+   |        Required: () ->{p, q²} Unit
    |
    |        where:    q  is a parameter in method inner
    |                  q² is a parameter in method test
@@ -12,19 +12,31 @@
 12 |    x = (q: Proc)   // error
    |         ^^^^^^^
    |         Found:    Proc
-   |         Required: box () ->{p, q} Unit
-   |
-   |         Note that () => Unit cannot be box-converted to box () ->{p, q} Unit
-   |         since at least one of their capture sets contains the root capability `cap`
+   |         Required: () ->{p, q} Unit
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/outer-var.scala:13:9 -------------------------------------
 13 |    y = (q: Proc)   // error
    |         ^^^^^^^
    |         Found:    Proc
-   |         Required: box () => Unit
+   |         Required: () ->{p} Unit
+   |
+   |         Note that the universal capability `cap`
+   |         cannot be included in capture set {p} of variable y
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/outer-var.scala:14:8 -------------------------------------
+14 |    y = q           // error, was OK under unsealed
+   |        ^
+   |        Found:    (q : Proc)
+   |        Required: () ->{p} Unit
    |
-   |         Note that () => Unit cannot be box-converted to box () => Unit
-   |         since at least one of their capture sets contains the root capability `cap`
+   |        Note that reference (q : Proc), defined in method inner
+   |        cannot be included in outer capture set {p} of variable y
    |
    | longer explanation available when compiling with `-explain`
+-- Error: tests/neg-custom-args/captures/outer-var.scala:16:57 ---------------------------------------------------------
+16 |  var finalizeActions = collection.mutable.ListBuffer[() => Unit]() // error, was OK under unsealed
+   |                                                      ^^^^^^^^^^
+   |                             Type variable A of object ListBuffer cannot be instantiated to box () => Unit since
+   |                             that type captures the root capability `cap`.
diff --git a/tests/neg-custom-args/captures/outer-var.scala b/tests/neg-custom-args/captures/outer-var.scala
index e26cd631602a..f869bfbfc387 100644
--- a/tests/neg-custom-args/captures/outer-var.scala
+++ b/tests/neg-custom-args/captures/outer-var.scala
@@ -11,8 +11,8 @@ def test(p: Proc, q: () => Unit) =
     x = q           // error
     x = (q: Proc)   // error
     y = (q: Proc)   // error
-    y = q           // OK, was error under sealed
+    y = q           // error, was OK under unsealed
 
-  var finalizeActions = collection.mutable.ListBuffer[() => Unit]() // OK, was error under sealed
+  var finalizeActions = collection.mutable.ListBuffer[() => Unit]() // error, was OK under unsealed
 
 
diff --git a/tests/neg-custom-args/captures/reaches.check b/tests/neg-custom-args/captures/reaches.check
index 0121f0cf7a55..7c00fa7299fe 100644
--- a/tests/neg-custom-args/captures/reaches.check
+++ b/tests/neg-custom-args/captures/reaches.check
@@ -15,16 +15,21 @@
    |       cannot be included in outer capture set {xs*} of value cur
    |
    | longer explanation available when compiling with `-explain`
--- Error: tests/neg-custom-args/captures/reaches.scala:38:31 -----------------------------------------------------------
-38 |    val next: () => Unit = cur.head // error
-   |                           ^^^^^^^^
-   |                       The expression's type box () => Unit is not allowed to capture the root capability `cap`.
-   |                       This usually means that a capability persists longer than its allowed lifetime.
--- Error: tests/neg-custom-args/captures/reaches.scala:45:35 -----------------------------------------------------------
-45 |    val next: () => Unit = cur.get.head // error
-   |                           ^^^^^^^^^^^^
-   |                       The expression's type box () => Unit is not allowed to capture the root capability `cap`.
-   |                       This usually means that a capability persists longer than its allowed lifetime.
+-- Error: tests/neg-custom-args/captures/reaches.scala:36:6 ------------------------------------------------------------
+36 |  var cur: List[Proc] = xs   // error
+   |      ^
+   |      Mutable variable cur cannot have type List[box () => Unit] since
+   |      the part box () => Unit of that type captures the root capability `cap`.
+-- Error: tests/neg-custom-args/captures/reaches.scala:43:16 -----------------------------------------------------------
+43 |  val cur = Ref[List[Proc]](xs) // error
+   |                ^^^^^^^^^^
+   |                Type variable T of constructor Ref cannot be instantiated to List[box () => Unit] since
+   |                the part box () => Unit of that type captures the root capability `cap`.
+-- Error: tests/neg-custom-args/captures/reaches.scala:53:51 -----------------------------------------------------------
+53 |  val id: Id[Proc, Proc] = new Id[Proc, () -> Unit] // error
+   |                                                   ^
+   |                                Type variable A of constructor Id cannot be instantiated to box () => Unit since
+   |                                that type captures the root capability `cap`.
 -- Error: tests/neg-custom-args/captures/reaches.scala:55:6 ------------------------------------------------------------
 55 |    id(() => f.write()) // error
    |    ^^^^^^^^^^^^^^^^^^^
@@ -46,12 +51,6 @@
    |             ^
    |             Local reach capability ps* leaks into capture scope of method mapCompose.
    |             To allow this, the parameter ps should be declared with a @use annotation
--- [E057] Type Mismatch Error: tests/neg-custom-args/captures/reaches.scala:53:51 --------------------------------------
-53 |  val id: Id[Proc, Proc] = new Id[Proc, () -> Unit] // error
-   |                                                   ^
-   |                                             Type argument () -> Unit does not conform to lower bound () => Unit
-   |
-   | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/reaches.scala:61:31 -----------------------------------------------------------
 61 |  val leaked = usingFile[File^{id*}]: f => // error
    |                               ^^^
diff --git a/tests/neg-custom-args/captures/reaches.scala b/tests/neg-custom-args/captures/reaches.scala
index 066c40031553..a9773b76f445 100644
--- a/tests/neg-custom-args/captures/reaches.scala
+++ b/tests/neg-custom-args/captures/reaches.scala
@@ -33,16 +33,16 @@ def runAll1(@use xs: List[Proc]): Unit =
       (() => f.write()) :: Nil // error
 
 def runAll2(xs: List[Proc]): Unit =
-  var cur: List[Proc] = xs
+  var cur: List[Proc] = xs   // error
   while cur.nonEmpty do
-    val next: () => Unit = cur.head // error
+    val next: () => Unit = cur.head
     next()
     cur = cur.tail
 
 def runAll3(xs: List[Proc]): Unit =
-  val cur = Ref[List[Proc]](xs)
+  val cur = Ref[List[Proc]](xs) // error
   while cur.get.nonEmpty do
-    val next: () => Unit = cur.get.head // error
+    val next: () => Unit = cur.get.head
     next()
     cur.set(cur.get.tail: List[Proc])
 
diff --git a/tests/neg-custom-args/captures/real-try.check b/tests/neg-custom-args/captures/real-try.check
index 6df092885384..a6f514addc95 100644
--- a/tests/neg-custom-args/captures/real-try.check
+++ b/tests/neg-custom-args/captures/real-try.check
@@ -7,7 +7,7 @@
 -- Error: tests/neg-custom-args/captures/real-try.scala:14:2 -----------------------------------------------------------
 14 |  try  // error
    |  ^
-   |  result of `try` cannot have type () => Unit since
+   |  The result of `try` cannot have type () => Unit since
    |  that type captures the root capability `cap`.
    |  This is often caused by a locally generated exception capability leaking as part of its result.
 15 |    () => foo(1)
@@ -17,7 +17,7 @@
 -- Error: tests/neg-custom-args/captures/real-try.scala:20:10 ----------------------------------------------------------
 20 |  val x = try // error
    |          ^
-   |          result of `try` cannot have type () => Unit since
+   |          The result of `try` cannot have type () => Unit since
    |          that type captures the root capability `cap`.
    |          This is often caused by a locally generated exception capability leaking as part of its result.
 21 |    () => foo(1)
@@ -27,7 +27,7 @@
 -- Error: tests/neg-custom-args/captures/real-try.scala:26:10 ----------------------------------------------------------
 26 |  val y = try  // error
    |          ^
-   |          result of `try` cannot have type () => Cell[Unit]^? since
+   |          The result of `try` cannot have type () => (ex$8: caps.Exists) -> Cell[Unit]^? since
    |          that type captures the root capability `cap`.
    |          This is often caused by a locally generated exception capability leaking as part of its result.
 27 |    () => Cell(foo(1))
@@ -37,7 +37,7 @@
 -- Error: tests/neg-custom-args/captures/real-try.scala:32:10 ----------------------------------------------------------
 32 |  val b = try // error
    |          ^
-   |          result of `try` cannot have type Cell[box () => Unit]^? since
+   |          The result of `try` cannot have type Cell[box () => Unit]^? since
    |          the part box () => Unit of that type captures the root capability `cap`.
    |          This is often caused by a locally generated exception capability leaking as part of its result.
 33 |    Cell(() => foo(1))
diff --git a/tests/neg-custom-args/captures/real-try.scala b/tests/neg-custom-args/captures/real-try.scala
index 8e60d4fe7326..32e976f654a9 100644
--- a/tests/neg-custom-args/captures/real-try.scala
+++ b/tests/neg-custom-args/captures/real-try.scala
@@ -1,5 +1,5 @@
-//> using options -source 3.4
-// (to make sure we use the sealed policy)
+
+
 import language.experimental.saferExceptions
 
 class Ex1 extends Exception("Ex1")
diff --git a/tests/neg-custom-args/captures/try.check b/tests/neg-custom-args/captures/try.check
index 77a5fc06e05a..9c49c444c82f 100644
--- a/tests/neg-custom-args/captures/try.check
+++ b/tests/neg-custom-args/captures/try.check
@@ -1,12 +1,8 @@
--- Error: tests/neg-custom-args/captures/try.scala:25:3 ----------------------------------------------------------------
-23 |  val a = handle[Exception, CanThrow[Exception]] {
-24 |    (x: CanThrow[Exception]) => x
-25 |  }{  // error (but could be better)
-   |          ^
-   |          The expression's type box CT[Exception]^ is not allowed to capture the root capability `cap`.
-   |          This usually means that a capability persists longer than its allowed lifetime.
-26 |    (ex: Exception) => ???
-27 |  }
+-- Error: tests/neg-custom-args/captures/try.scala:23:28 ---------------------------------------------------------------
+23 |  val a = handle[Exception, CanThrow[Exception]] { // error
+   |                            ^^^^^^^^^^^^^^^^^^^
+   |                            Type variable R of method handle cannot be instantiated to box CT[Exception]^ since
+   |                            that type captures the root capability `cap`.
 -- Error: tests/neg-custom-args/captures/try.scala:30:65 ---------------------------------------------------------------
 30 |    (x: CanThrow[Exception]) => () => raise(new Exception)(using x) // error
    |                                                                 ^
diff --git a/tests/neg-custom-args/captures/try.scala b/tests/neg-custom-args/captures/try.scala
index 45a1b346a512..a85a18f69caa 100644
--- a/tests/neg-custom-args/captures/try.scala
+++ b/tests/neg-custom-args/captures/try.scala
@@ -20,9 +20,9 @@ def handle[E <: Exception,  R <: Top](op: CT[E]^ => R)(handler: E => R): R =
   catch case ex: E => handler(ex)
 
 def test =
-  val a = handle[Exception, CanThrow[Exception]] {
+  val a = handle[Exception, CanThrow[Exception]] { // error
     (x: CanThrow[Exception]) => x
-  }{  // error (but could be better)
+  }{
     (ex: Exception) => ???
   }
 
diff --git a/tests/neg-custom-args/captures/unbox.scala b/tests/neg-custom-args/captures/unbox.scala
index 33702a954068..28feb5f89aff 100644
--- a/tests/neg-custom-args/captures/unbox.scala
+++ b/tests/neg-custom-args/captures/unbox.scala
@@ -1,4 +1,4 @@
-import language.`3.2`
+import language.`3.5`
 type Proc = () => Unit
 
 val xs: List[Proc] = ???
diff --git a/tests/neg-custom-args/captures/unsound-reach-2.scala b/tests/neg-custom-args/captures/unsound-reach-2.scala
index 5bea18bdccba..c7dfa117a2fe 100644
--- a/tests/neg-custom-args/captures/unsound-reach-2.scala
+++ b/tests/neg-custom-args/captures/unsound-reach-2.scala
@@ -1,5 +1,3 @@
-//> using options -source 3.4
-// (to make sure we use the sealed policy)
 import language.experimental.captureChecking
 trait Consumer[-T]:
   def apply(x: T): Unit
@@ -11,7 +9,7 @@ def withFile[R](path: String)(op: Consumer[File]): R = ???
 
 trait Foo[+X]:
   def use(x: File^)(op: Consumer[X]): Unit
-class Bar extends Foo[File^]:
+class Bar extends Foo[File^]: // error
   def use(x: File^)(op: Consumer[File^]): Unit = op.apply(x)
 
 def bad(): Unit =
diff --git a/tests/neg-custom-args/captures/unsound-reach-3.scala b/tests/neg-custom-args/captures/unsound-reach-3.scala
index 985beb7ae55d..c5cdfca9d87a 100644
--- a/tests/neg-custom-args/captures/unsound-reach-3.scala
+++ b/tests/neg-custom-args/captures/unsound-reach-3.scala
@@ -1,5 +1,5 @@
-//> using options -source 3.4
-// (to make sure we use the sealed policy)
+
+
 import language.experimental.captureChecking
 trait File:
   def close(): Unit
@@ -8,7 +8,7 @@ def withFile[R](path: String)(op: File^ => R): R = ???
 
 trait Foo[+X]:
   def use(x: File^): X
-class Bar extends Foo[File^]:
+class Bar extends Foo[File^]: // error
   def use(x: File^): File^ = x
 
 def bad(): Unit =
diff --git a/tests/neg-custom-args/captures/unsound-reach-4.check b/tests/neg-custom-args/captures/unsound-reach-4.check
index ed8e29cdf511..ca95bf42ba59 100644
--- a/tests/neg-custom-args/captures/unsound-reach-4.check
+++ b/tests/neg-custom-args/captures/unsound-reach-4.check
@@ -1,3 +1,8 @@
+-- Error: tests/neg-custom-args/captures/unsound-reach-4.scala:13:18 ---------------------------------------------------
+13 |class Bar extends Foo[File^]: // error
+   |                  ^^^^^^^^^^
+   |                  Type variable X of trait Foo cannot be instantiated to File^ since
+   |                  that type captures the root capability `cap`.
 -- Error: tests/neg-custom-args/captures/unsound-reach-4.scala:22:22 ---------------------------------------------------
 22 |    escaped = boom.use(f)  // error
    |              ^^^^^^^^^^^
diff --git a/tests/neg-custom-args/captures/unsound-reach-4.scala b/tests/neg-custom-args/captures/unsound-reach-4.scala
index 14050b4afff2..88fbc2f5c1de 100644
--- a/tests/neg-custom-args/captures/unsound-reach-4.scala
+++ b/tests/neg-custom-args/captures/unsound-reach-4.scala
@@ -1,5 +1,5 @@
-//> using options -source 3.4
-// (to make sure we use the sealed policy)
+
+
 import language.experimental.captureChecking
 trait File:
   def close(): Unit
@@ -10,7 +10,7 @@ type F = File^
 
 trait Foo[+X]:
   def use(x: F): X
-class Bar extends Foo[File^]:
+class Bar extends Foo[File^]: // error
   def use(x: F): File^ = x
 
 def bad(): Unit =
diff --git a/tests/neg-custom-args/captures/unsound-reach.check b/tests/neg-custom-args/captures/unsound-reach.check
index 4a6793d204c5..69794f569edb 100644
--- a/tests/neg-custom-args/captures/unsound-reach.check
+++ b/tests/neg-custom-args/captures/unsound-reach.check
@@ -1,12 +1,15 @@
--- Error: tests/neg-custom-args/captures/unsound-reach.scala:18:21 -----------------------------------------------------
-18 |        boom.use(f): (f1: File^{backdoor*}) => // error
+-- Error: tests/neg-custom-args/captures/unsound-reach.scala:9:18 ------------------------------------------------------
+9 |class Bar extends Foo[File^]: // error
+  |                  ^^^^^^^^^^
+  |                  Type variable X of trait Foo cannot be instantiated to File^ since
+  |                  that type captures the root capability `cap`.
+-- Error: tests/neg-custom-args/captures/unsound-reach.scala:14:19 -----------------------------------------------------
+14 |class Bar2 extends Foo2[File^]: // error
+   |                   ^
+   |                   Type variable X of constructor Foo2 cannot be instantiated to box File^ since
+   |                   that type captures the root capability `cap`.
+-- Error: tests/neg-custom-args/captures/unsound-reach.scala:23:21 -----------------------------------------------------
+23 |        boom.use(f): (f1: File^{backdoor*}) => // error
    |                     ^
    |                     Local reach capability backdoor* leaks into capture scope of method bad
-19 |            escaped = f1
--- [E164] Declaration Error: tests/neg-custom-args/captures/unsound-reach.scala:10:8 -----------------------------------
-10 |    def use(x: File^)(op: File^ => Unit): Unit = op(x) // error, was OK using sealed checking
-   |        ^
-   |        error overriding method use in trait Foo of type (x: File^)(op: box File^ => Unit): Unit;
-   |          method use of type (x: File^)(op: File^ => Unit): Unit has incompatible type
-   |
-   | longer explanation available when compiling with `-explain`
+24 |            escaped = f1
diff --git a/tests/neg-custom-args/captures/unsound-reach.scala b/tests/neg-custom-args/captures/unsound-reach.scala
index c3c31a7f32ff..3fb666c7c1fc 100644
--- a/tests/neg-custom-args/captures/unsound-reach.scala
+++ b/tests/neg-custom-args/captures/unsound-reach.scala
@@ -6,8 +6,13 @@ def withFile[R](path: String)(op: File^ => R): R = ???
 
 trait Foo[+X]:
     def use(x: File^)(op: X => Unit): Unit
-class Bar extends Foo[File^]:
-    def use(x: File^)(op: File^ => Unit): Unit = op(x) // error, was OK using sealed checking
+class Bar extends Foo[File^]: // error
+    def use(x: File^)(op: File^ => Unit): Unit = op(x) // OK using sealed checking
+
+abstract class Foo2[+X]():
+    def use(x: File^)(op: X => Unit): Unit
+class Bar2 extends Foo2[File^]: // error
+    def use(x: File^)(op: File^ => Unit): Unit = op(x) // OK using sealed checking
 
 def bad(): Unit =
     val backdoor: Foo[File^] = new Bar
diff --git a/tests/neg-custom-args/captures/vars-simple.check b/tests/neg-custom-args/captures/vars-simple.check
index 2ef301b6ec1f..2bc014e9a4e7 100644
--- a/tests/neg-custom-args/captures/vars-simple.check
+++ b/tests/neg-custom-args/captures/vars-simple.check
@@ -2,17 +2,14 @@
 15 |    a = (g: String => String)      // error
    |         ^^^^^^^^^^^^^^^^^^^
    |         Found:    String => String
-   |         Required: box String ->{cap1, cap2} String
-   |
-   |         Note that String => String cannot be box-converted to box String ->{cap1, cap2} String
-   |         since at least one of their capture sets contains the root capability `cap`
+   |         Required: String ->{cap1, cap2} String
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/vars-simple.scala:16:8 -----------------------------------
 16 |    a = g  // error
    |        ^
-   |        Found:    box (x: String) ->{cap3} String
-   |        Required: box (x: String) ->{cap1, cap2} String
+   |        Found:    (x: String) ->{cap3} String
+   |        Required: (x: String) ->{cap1, cap2} String
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/vars-simple.scala:17:12 ----------------------------------
diff --git a/tests/neg-custom-args/captures/vars.scala b/tests/neg-custom-args/captures/vars.scala
index 5eb1e3fedda9..eb9719cd2adf 100644
--- a/tests/neg-custom-args/captures/vars.scala
+++ b/tests/neg-custom-args/captures/vars.scala
@@ -1,5 +1,5 @@
-//> using options -source 3.4
-// (to make sure we use the sealed policy)
+
+
 class CC
 type Cap = CC^
 
diff --git a/tests/neg-custom-args/captures/widen-reach.check b/tests/neg-custom-args/captures/widen-reach.check
index abc065a1e2bc..9fe1f2bd5de6 100644
--- a/tests/neg-custom-args/captures/widen-reach.check
+++ b/tests/neg-custom-args/captures/widen-reach.check
@@ -1,3 +1,8 @@
+-- Error: tests/neg-custom-args/captures/widen-reach.scala:8:18 --------------------------------------------------------
+8 |trait Bar extends Foo[IO^]: // error
+  |                  ^^^^^^^^
+  |                  Type variable T of trait Foo cannot be instantiated to IO^ since
+  |                  that type captures the root capability `cap`.
 -- Error: tests/neg-custom-args/captures/widen-reach.scala:13:26 -------------------------------------------------------
 13 |  val y2: IO^ -> IO^ = y1.foo      // error
    |                       ^^^^^^
@@ -8,10 +13,3 @@
    |                           ^^^^^^
    |                           Local reach capability x* leaks into capture scope of method test.
    |                           To allow this, the parameter x should be declared with a @use annotation
--- [E164] Declaration Error: tests/neg-custom-args/captures/widen-reach.scala:9:6 --------------------------------------
-9 |  val foo: IO^ -> IO^ = x => x // error
-  |      ^
-  |      error overriding value foo in trait Foo of type IO^ -> box IO^;
-  |        value foo of type IO^ -> (ex$3: caps.Exists) -> IO^{ex$3} has incompatible type
-  |
-  | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/widen-reach.scala b/tests/neg-custom-args/captures/widen-reach.scala
index fa5eee1232df..9a9305640473 100644
--- a/tests/neg-custom-args/captures/widen-reach.scala
+++ b/tests/neg-custom-args/captures/widen-reach.scala
@@ -5,8 +5,8 @@ trait IO
 trait Foo[+T]:
   val foo: IO^ -> T
 
-trait Bar extends Foo[IO^]:
-  val foo: IO^ -> IO^ = x => x // error
+trait Bar extends Foo[IO^]: // error
+  val foo: IO^ -> IO^ = x => x
 
 def test(x: Foo[IO^]): Unit =
   val y1: Foo[IO^{x*}] = x
diff --git a/tests/pos-custom-args/captures/hk-param.scala b/tests/pos-custom-args/captures/hk-param.scala
index df4335069bbb..325a2b55a480 100644
--- a/tests/pos-custom-args/captures/hk-param.scala
+++ b/tests/pos-custom-args/captures/hk-param.scala
@@ -1,3 +1,5 @@
+//> using options -source 3.5
+// (to make sure we use the unsealed policy)
 /** Concrete collection type: View */
 trait View[+A] extends Itable[A], ILike[A, [X] =>> View[X]^]:
   override def fromIterable[B](c: Itable[B]^): View[B]^{c} = ???
diff --git a/tests/pos-custom-args/captures/i15923-cases.scala b/tests/pos-custom-args/captures/i15923-cases.scala
index 4b5a36f208ec..c48ca430c440 100644
--- a/tests/pos-custom-args/captures/i15923-cases.scala
+++ b/tests/pos-custom-args/captures/i15923-cases.scala
@@ -2,6 +2,10 @@ trait Cap { def use(): Int }
 type Id[X] = [T] -> (op: X => T) -> T
 def mkId[X](x: X): Id[X] = [T] => (op: X => T) => op(x)
 
+def foo(x: Id[Cap^]) = {
+  x(_.use())  // OK under sealed policy
+}
+
 def bar(io: Cap^, x: Id[Cap^{io}]) = {
   x(_.use())
 }
diff --git a/tests/pos-custom-args/captures/levels.scala b/tests/pos-custom-args/captures/levels.scala
index cabd537442a5..4d9d759e86db 100644
--- a/tests/pos-custom-args/captures/levels.scala
+++ b/tests/pos-custom-args/captures/levels.scala
@@ -1,3 +1,5 @@
+//> using options -source 3.5
+// (to make sure we use the unsealed policy)
 class CC
 
 def test1(cap1: CC^) =
@@ -14,10 +16,10 @@ def test2(cap1: CC^) =
     def setV(x: T): Unit = v = x
     def getV: T = v
 
-  val _ = Ref[String => String]((x: String) => x) // ok
+  val _ = Ref[String => String]((x: String) => x)
   val r = Ref((x: String) => x)
 
   def scope(cap3: CC^) =
     def g(x: String): String = if cap3 == cap3 then "" else "a"
-    r.setV(g) // error
+    r.setV(g)
   ()

From 62b2f1c250fc6934f5929b1ba3123b9b60bb5a72 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 2 Nov 2024 12:04:06 +0100
Subject: [PATCH 211/306] Follow upper bounds of type variables when computing
 dcs

---
 .../src/dotty/tools/dotc/cc/CaptureSet.scala  |  4 ++++
 .../dotty/tools/dotc/cc/CheckCaptures.scala   |  2 +-
 compiler/src/dotty/tools/dotc/cc/Setup.scala  |  4 ++++
 tests/neg-custom-args/captures/dcs-tvar.check | 10 +++++++++
 tests/neg-custom-args/captures/dcs-tvar.scala |  9 ++++++++
 tests/neg-custom-args/captures/i21646.scala   |  2 +-
 .../captures/unsound-reach-6.scala            | 22 +++++++++++++++++++
 .../captures/use-override.scala               | 15 +++++++++++++
 tests/pos-custom-args/captures/i21646.scala   | 13 +++++++++++
 9 files changed, 79 insertions(+), 2 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/dcs-tvar.check
 create mode 100644 tests/neg-custom-args/captures/dcs-tvar.scala
 create mode 100644 tests/neg-custom-args/captures/unsound-reach-6.scala
 create mode 100644 tests/neg-custom-args/captures/use-override.scala
 create mode 100644 tests/pos-custom-args/captures/i21646.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
index 835e413463bd..cde0431e3e86 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
@@ -1120,6 +1120,7 @@ object CaptureSet:
    */
   def ofTypeDeeply(tp: Type)(using Context): CaptureSet =
     val collect = new TypeAccumulator[CaptureSet]:
+      val seen = util.HashSet[Symbol]()
       def apply(cs: CaptureSet, t: Type) =
         if variance <= 0 then cs
         else t.dealias match
@@ -1127,6 +1128,9 @@ object CaptureSet:
             this(cs, p) ++ cs1
           case t @ AnnotatedType(parent, ann) =>
             this(cs, parent)
+          case t: TypeRef if t.symbol.isAbstractOrParamType && !seen.contains(t.symbol) =>
+            seen += t.symbol
+            this(cs, t.info.bounds.hi)
           case t @ FunctionOrMethod(args, res @ Existential(_, _))
           if args.forall(_.isAlwaysPure) =>
             this(cs, Existential.toCap(res))
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index cce5a7cd21dd..7a5c8b884ffc 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -660,7 +660,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           for (getterName, argType) <- mt.paramNames.lazyZip(argTypes) do
             val getter = cls.info.member(getterName).suchThat(_.isRefiningParamAccessor).symbol
             if !getter.is(Private) && getter.hasTrackedParts then
-              refined = RefinedType(refined, getterName, argType)
+              refined = RefinedType(refined, getterName, argType.unboxed)
               allCaptures ++= argType.captureSet
           (refined, allCaptures)
 
diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index 56afaa1b33fb..dc78761b76e8 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -81,11 +81,15 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
   private def newFlagsFor(symd: SymDenotation)(using Context): FlagSet =
 
     object containsCovarRetains extends TypeAccumulator[Boolean]:
+      val seen = util.HashSet[Symbol]()
       def apply(x: Boolean, tp: Type): Boolean =
         if x then true
         else if tp.derivesFromCapability && variance >= 0 then true
         else tp match
           case AnnotatedType(_, ann) if ann.symbol.isRetains && variance >= 0 => true
+          case t: TypeRef if t.symbol.isAbstractOrParamType && !seen.contains(t.symbol) =>
+            seen += t.symbol
+            apply(x, t.info.bounds.hi)
           case _ => foldOver(x, tp)
       def apply(tp: Type): Boolean = apply(false, tp)
 
diff --git a/tests/neg-custom-args/captures/dcs-tvar.check b/tests/neg-custom-args/captures/dcs-tvar.check
new file mode 100644
index 000000000000..d3caa720e88a
--- /dev/null
+++ b/tests/neg-custom-args/captures/dcs-tvar.check
@@ -0,0 +1,10 @@
+-- Error: tests/neg-custom-args/captures/dcs-tvar.scala:6:15 -----------------------------------------------------------
+6 |  () => runOps(xs) // error
+  |               ^^
+  |               reference xs* is not included in the allowed capture set {}
+  |               of an enclosing function literal with expected type () -> Unit
+-- Error: tests/neg-custom-args/captures/dcs-tvar.scala:9:15 -----------------------------------------------------------
+9 |  () => runOps(xs) // error
+  |               ^^
+  |               reference xs* is not included in the allowed capture set {}
+  |               of an enclosing function literal with expected type () -> Unit
diff --git a/tests/neg-custom-args/captures/dcs-tvar.scala b/tests/neg-custom-args/captures/dcs-tvar.scala
new file mode 100644
index 000000000000..381c08b4d351
--- /dev/null
+++ b/tests/neg-custom-args/captures/dcs-tvar.scala
@@ -0,0 +1,9 @@
+import caps.use
+
+def runOps(@use xs: List[() => Unit]): Unit = ???
+
+def f[T <: List[() => Unit]](xs: T): () -> Unit =
+  () => runOps(xs) // error
+
+def g[T <: List[U], U <: () => Unit](xs: T): () -> Unit =
+  () => runOps(xs) // error
diff --git a/tests/neg-custom-args/captures/i21646.scala b/tests/neg-custom-args/captures/i21646.scala
index cf451ded3120..92aba9fda5d1 100644
--- a/tests/neg-custom-args/captures/i21646.scala
+++ b/tests/neg-custom-args/captures/i21646.scala
@@ -9,5 +9,5 @@ class Resource[T <: Capability](gen: T):
 
 @main def run =
   val myFile: File = ???
-  val r = Resource(myFile) // error
+  val r = Resource(myFile) // now ok, was error
   ()
diff --git a/tests/neg-custom-args/captures/unsound-reach-6.scala b/tests/neg-custom-args/captures/unsound-reach-6.scala
new file mode 100644
index 000000000000..b7306dca4190
--- /dev/null
+++ b/tests/neg-custom-args/captures/unsound-reach-6.scala
@@ -0,0 +1,22 @@
+class IO
+
+def f(xs: List[() => Unit]): () => Unit = () =>
+  println(xs.head) // error
+
+def test(io: IO^)(ys: List[() ->{io} Unit]) =
+  val x = () =>
+    val z = f(ys)
+    z()
+  val _: () -> Unit = x // !!! ys* gets lost
+  ()
+
+def test(io: IO^) =
+  def ys: List[() ->{io} Unit] = ???
+  val x = () =>
+    val z = f(ys)
+    z()
+  val _: () -> Unit = x // !!! io gets lost
+  ()
+
+
+
diff --git a/tests/neg-custom-args/captures/use-override.scala b/tests/neg-custom-args/captures/use-override.scala
new file mode 100644
index 000000000000..febb59ca4208
--- /dev/null
+++ b/tests/neg-custom-args/captures/use-override.scala
@@ -0,0 +1,15 @@
+import caps.use
+
+def test(io: Object^, async: Object^) =
+
+  trait A:
+    def f(@use x: List[() ->{io} Unit]): Unit
+
+  class B extends A:
+    def f(@use x: List[() => Unit]): Unit =  // error, would be unsound if allowed
+      x.foreach(_())
+
+  class C extends A:
+    def f(@use x: List[() ->{io, async} Unit]): Unit =  // error, this one could be soundly allowed actually
+      x.foreach(_())
+
diff --git a/tests/pos-custom-args/captures/i21646.scala b/tests/pos-custom-args/captures/i21646.scala
new file mode 100644
index 000000000000..cf451ded3120
--- /dev/null
+++ b/tests/pos-custom-args/captures/i21646.scala
@@ -0,0 +1,13 @@
+import language.experimental.captureChecking
+import caps.Capability
+
+trait File extends Capability
+
+class Resource[T <: Capability](gen: T):
+  def use[U](f: T => U): U =
+    f(gen) // OK, was error under unsealed
+
+@main def run =
+  val myFile: File = ???
+  val r = Resource(myFile) // error
+  ()

From 06764503f01b45fac467557c4399b84b967fa77d Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 2 Nov 2024 12:19:08 +0100
Subject: [PATCH 212/306] Check that @use annotations only appear for method
 and class parameters

---
 compiler/src/dotty/tools/dotc/cc/Setup.scala    | 11 +++++++++++
 tests/neg-custom-args/captures/bad-uses-2.scala |  6 ++++++
 tests/neg-custom-args/captures/bad-uses.scala   |  3 +++
 tests/neg-custom-args/captures/i21646.scala     | 13 -------------
 tests/pending/pos/function-contravariance.scala | 10 ++++++++++
 tests/pos-custom-args/captures/i21646.scala     |  2 +-
 6 files changed, 31 insertions(+), 14 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/bad-uses-2.scala
 create mode 100644 tests/neg-custom-args/captures/bad-uses.scala
 delete mode 100644 tests/neg-custom-args/captures/i21646.scala
 create mode 100644 tests/pending/pos/function-contravariance.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index dc78761b76e8..647e5a2cfd51 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -495,6 +495,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         case _ =>
           traverseChildren(tree)
       postProcess(tree)
+      checkProperUse(tree)
     end traverse
 
     def postProcess(tree: Tree)(using Context): Unit = tree match
@@ -637,6 +638,16 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           case _ =>
       case _ =>
     end postProcess
+
+    def checkProperUse(tree: Tree)(using Context): Unit = tree match
+      case tree: MemberDef =>
+        def useAllowed(sym: Symbol) =
+          (sym.is(Param) || sym.is(ParamAccessor)) && !sym.owner.isAnonymousFunction
+        for ann <- tree.symbol.annotations do
+          if ann.symbol == defn.UseAnnot && !useAllowed(tree.symbol) then
+            report.error(i"Only parameters of methods can have @use annotations", tree.srcPos)
+      case _ =>
+    end checkProperUse
   end setupTraverser
 
   /** Checks whether an abstract type could be impure. See also: [[needsVariable]]. */
diff --git a/tests/neg-custom-args/captures/bad-uses-2.scala b/tests/neg-custom-args/captures/bad-uses-2.scala
new file mode 100644
index 000000000000..00eec3e5a2e9
--- /dev/null
+++ b/tests/neg-custom-args/captures/bad-uses-2.scala
@@ -0,0 +1,6 @@
+import caps.use
+class Test:
+  @use def F = ???  // error
+  @use val x = ???  // error
+  @use type T       // error
+  def foo(@use c: Test): Unit = ??? // OK
diff --git a/tests/neg-custom-args/captures/bad-uses.scala b/tests/neg-custom-args/captures/bad-uses.scala
new file mode 100644
index 000000000000..c21976ebb3cf
--- /dev/null
+++ b/tests/neg-custom-args/captures/bad-uses.scala
@@ -0,0 +1,3 @@
+import caps.use
+class Test:
+  val bar = (@use c: Test) => () // error
diff --git a/tests/neg-custom-args/captures/i21646.scala b/tests/neg-custom-args/captures/i21646.scala
deleted file mode 100644
index 92aba9fda5d1..000000000000
--- a/tests/neg-custom-args/captures/i21646.scala
+++ /dev/null
@@ -1,13 +0,0 @@
-import language.experimental.captureChecking
-import caps.Capability
-
-trait File extends Capability
-
-class Resource[T <: Capability](gen: T):
-  def use[U](f: T => U): U =
-    f(gen) // OK, was error under unsealed
-
-@main def run =
-  val myFile: File = ???
-  val r = Resource(myFile) // now ok, was error
-  ()
diff --git a/tests/pending/pos/function-contravariance.scala b/tests/pending/pos/function-contravariance.scala
new file mode 100644
index 000000000000..4df88f890bed
--- /dev/null
+++ b/tests/pending/pos/function-contravariance.scala
@@ -0,0 +1,10 @@
+import language.experimental.namedTuples
+
+class A:
+  type T
+
+class B extends A
+
+val f: (x: A) => x.T = ???
+val g: (x: B) => x.T = f // OK
+val h: (x: A) => x.T = g // error
diff --git a/tests/pos-custom-args/captures/i21646.scala b/tests/pos-custom-args/captures/i21646.scala
index cf451ded3120..92aba9fda5d1 100644
--- a/tests/pos-custom-args/captures/i21646.scala
+++ b/tests/pos-custom-args/captures/i21646.scala
@@ -9,5 +9,5 @@ class Resource[T <: Capability](gen: T):
 
 @main def run =
   val myFile: File = ???
-  val r = Resource(myFile) // error
+  val r = Resource(myFile) // now ok, was error
   ()

From 96d1610fe8ba71b3e2d6e8d84744e7d982a9c9bc Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 2 Nov 2024 15:50:10 +0100
Subject: [PATCH 213/306] Refactorings and drop useExistential Config option

---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  |  27 +--
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 165 ++++++++----------
 .../src/dotty/tools/dotc/cc/Existential.scala |   6 +-
 3 files changed, 76 insertions(+), 122 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index 97c774b593a6..2dc2bbf77abe 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -38,10 +38,6 @@ object ccConfig:
    */
   inline val deferredReaches = false
 
-  /** If true, use existential capture set variables */
-  def useExistentials(using Context) =
-    Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.5`)
-
   /** If true, use "sealed" as encapsulation mechanism, meaning that we
    *  check that type variable instantiations don't have `cap` in any of
    *  their capture sets. This is an alternative of the original restriction
@@ -479,17 +475,6 @@ extension (tp: Type)
    *  occurrences of cap are allowed in instance types of type variables.
    */
   def withReachCaptures(ref: Type)(using Context): Type =
-    class CheckContraCaps extends TypeTraverser:
-      var ok = true
-      def traverse(t: Type): Unit =
-        if ok then
-          t.dealias match
-            case CapturingType(_, cs) if cs.isUniversal && variance <= 0 =>
-              ok = false
-            case _ =>
-              traverseChildren(t)
-    end CheckContraCaps
-
     object narrowCaps extends TypeMap:
       def apply(t: Type) =
         if variance <= 0 then t
@@ -512,15 +497,9 @@ extension (tp: Type)
 
     ref match
       case ref: CaptureRef if ref.isTrackableRef =>
-        val checker = new CheckContraCaps
-        if !ccConfig.useExistentials then checker.traverse(tp)
-        if checker.ok then
-          val tp1 = narrowCaps(tp)
-          if tp1 ne tp then capt.println(i"narrow $tp of $ref to $tp1")
-          tp1
-        else
-          capt.println(i"cannot narrow $tp of $ref")
-          tp
+        val tp1 = narrowCaps(tp)
+        if tp1 ne tp then capt.println(i"narrow $tp of $ref to $tp1")
+        tp1
       case _ =>
         tp
 
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 7a5c8b884ffc..8a7231866742 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -121,6 +121,9 @@ object CheckCaptures:
       def inverse = thisMap
   end SubstParamsBiMap
 
+  /** A prototype that indicates selection with an immutable value */
+  class PathSelectionProto(val sym: Symbol, val pt: Type)(using Context) extends WildcardSelectionProto
+
   /** Check that a @retains annotation only mentions references that can be tracked.
    *  This check is performed at Typer.
    */
@@ -144,9 +147,9 @@ object CheckCaptures:
         case ReachCapabilityApply(arg) => check(arg, elem.srcPos)
         case _ => check(elem, elem.srcPos)
 
-  /** Report an error if some part of `tp` contains the root capability in its capture set
-   *  or if it refers to an unsealed type parameter that could possibly be instantiated with
-   *  cap in a way that's visible at the type.
+  /** Under the sealed policy, report an error if some part of `tp` contains the
+   *  root capability in its capture set or if it refers to a type parameter that
+   *  could possibly be instantiated with cap in a way that's visible at the type.
    */
   private def disallowRootCapabilitiesIn(tp: Type, carrier: Symbol, what: String, have: String, addendum: String, pos: SrcPos)(using Context) =
     val check = new TypeTraverser:
@@ -182,8 +185,66 @@ object CheckCaptures:
     if ccConfig.useSealed then check.traverse(tp)
   end disallowRootCapabilitiesIn
 
-  /** A prototype that indicates selection with an immutable value */
-  class PathSelectionProto(val sym: Symbol, val pt: Type)(using Context) extends WildcardSelectionProto
+  /** Under the sealed policy, disallow the root capability in type arguments.
+   *  Type arguments come either from a TypeApply node or from an AppliedType
+   *  which represents a trait parent in a template.
+   *  @param  fn   the type application, of type TypeApply or TypeTree
+   *  @param  sym  the constructor symbol (could be a method or a val or a class)
+   *  @param  args the type arguments
+   */
+  private def disallowCapInTypeArgs(fn: Tree, sym: Symbol, args: List[Tree], thisPhase: Phase)(using Context): Unit =
+    def isExempt = sym.isTypeTestOrCast || sym == defn.Compiletime_erasedValue
+    if ccConfig.useSealed && !isExempt then
+      val paramNames = atPhase(thisPhase.prev):
+        fn.tpe.widenDealias match
+          case tl: TypeLambda => tl.paramNames
+          case ref: AppliedType if ref.typeSymbol.isClass => ref.typeSymbol.typeParams.map(_.name)
+          case t =>
+            println(i"parent type: $t")
+            args.map(_ => EmptyTypeName)
+      for case (arg: TypeTree, pname) <- args.lazyZip(paramNames) do
+        def where = if sym.exists then i" in an argument of $sym" else ""
+        val (addendum, pos) =
+          if arg.isInferred
+          then ("\nThis is often caused by a local capability$where\nleaking as part of its result.", fn.srcPos)
+          else if arg.span.exists then ("", arg.srcPos)
+          else ("", fn.srcPos)
+        disallowRootCapabilitiesIn(arg.knownType, NoSymbol,
+          i"Type variable $pname of $sym", "be instantiated to", addendum, pos)
+  end disallowCapInTypeArgs
+
+  /** If we are not under the sealed policy, and a tree is an application that unboxes
+   *  its result or is a try, check that the tree's type does not have covariant universal
+   *  capabilities.
+   */
+  private def checkNotUniversalInUnboxedResult(tpe: Type, tree: Tree)(using Context): Unit =
+    def needsUniversalCheck = tree match
+      case _: RefTree | _: Apply | _: TypeApply => tree.symbol.unboxesResult
+      case _: Try => true
+      case _ => false
+
+    object checkNotUniversal extends TypeTraverser:
+      def traverse(tp: Type) =
+        tp.dealias match
+        case wtp @ CapturingType(parent, refs) =>
+          if variance > 0 then
+            refs.disallowRootCapability: () =>
+              def part = if wtp eq tpe.widen then "" else i" in its part $wtp"
+              report.error(
+                em"""The expression's type ${tpe.widen} is not allowed to capture the root capability `cap`$part.
+                  |This usually means that a capability persists longer than its allowed lifetime.""",
+                tree.srcPos)
+          if !wtp.isBoxed then traverse(parent)
+        case tp =>
+          traverseChildren(tp)
+
+    if !ccConfig.useSealed
+        && !tpe.hasAnnotation(defn.UncheckedCapturesAnnot)
+        && needsUniversalCheck
+        && tpe.widen.isValueType
+    then
+      checkNotUniversal.traverse(tpe.widen)
+  end checkNotUniversalInUnboxedResult
 
 class CheckCaptures extends Recheck, SymTransformer:
   thisPhase =>
@@ -269,41 +330,6 @@ class CheckCaptures extends Recheck, SymTransformer:
     def showRef(ref: CaptureRef)(using Context): String =
         ctx.printer.toTextCaptureRef(ref).show
 
-    // Uses 4-space indent as a trial
-    private def checkReachCapsIsolated(tpe: Type, pos: SrcPos)(using Context): Unit =
-
-        object checker extends TypeTraverser:
-            var refVariances: Map[Boolean, Int] = Map.empty
-            var seenReach: CaptureRef | Null = null
-            def traverse(tp: Type) =
-                tp.dealias match
-                case CapturingType(parent, refs) =>
-                    traverse(parent)
-                    for ref <- refs.elems do
-                        if ref.isReach && !ref.stripReach.isInstanceOf[TermParamRef]
-                            || ref.isRootCapability
-                        then
-                            val isReach = ref.isReach
-                            def register() =
-                                refVariances = refVariances.updated(isReach, variance)
-                                seenReach = ref
-                            refVariances.get(isReach) match
-                                case None => register()
-                                case Some(v) => if v != 0 && variance == 0 then register()
-                case _ =>
-                    traverseChildren(tp)
-
-        checker.traverse(tpe)
-        if checker.refVariances.size == 2
-            && checker.refVariances(true) >= 0
-            && checker.refVariances(false) <= 0
-        then
-            report.error(
-                em"""Reach capability ${showRef(checker.seenReach.nn)} and universal capability cap cannot both
-                    |appear in the type $tpe of this expression""",
-                pos)
-    end checkReachCapsIsolated
-
     /** The current environment */
     private val rootEnv: Env = inContext(ictx):
       Env(defn.RootClass, EnvKind.Regular, CaptureSet.empty, null)
@@ -685,32 +711,11 @@ class CheckCaptures extends Recheck, SymTransformer:
       else ownType
     end instantiate
 
-    def disallowCapInTypeArgs(fn: Tree, sym: Symbol, args: List[Tree])(using Context): Unit =
-      def isExempt = sym.isTypeTestOrCast || sym == defn.Compiletime_erasedValue
-      if ccConfig.useSealed && !isExempt then
-        val paramNames = atPhase(thisPhase.prev):
-          fn.tpe.widenDealias match
-            case tl: TypeLambda => tl.paramNames
-            case ref: AppliedType if ref.typeSymbol.isClass => ref.typeSymbol.typeParams.map(_.name)
-            case t =>
-              println(i"parent type: $t")
-              args.map(_ => EmptyTypeName)
-        for case (arg: TypeTree, pname) <- args.lazyZip(paramNames) do
-          def where = if sym.exists then i" in an argument of $sym" else ""
-          val (addendum, pos) =
-            if arg.isInferred
-            then ("\nThis is often caused by a local capability$where\nleaking as part of its result.", fn.srcPos)
-            else if arg.span.exists then ("", arg.srcPos)
-            else ("", fn.srcPos)
-          disallowRootCapabilitiesIn(arg.knownType, NoSymbol,
-            i"Type variable $pname of $sym", "be instantiated to", addendum, pos)
-    end disallowCapInTypeArgs
-
     override def recheckTypeApply(tree: TypeApply, pt: Type)(using Context): Type =
       val meth = tree.fun match
         case fun @ Select(qual, nme.apply) => qual.symbol.orElse(fun.symbol)
         case fun => fun.symbol
-      disallowCapInTypeArgs(tree.fun, meth, tree.args)
+      disallowCapInTypeArgs(tree.fun, meth, tree.args, thisPhase)
       val res = Existential.toCap(super.recheckTypeApply(tree, pt))
       includeCallCaptures(tree.symbol, res, tree.srcPos)
       checkContains(tree)
@@ -940,7 +945,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         for case tpt: TypeTree <- impl.parents do
           tpt.tpe match
             case AppliedType(fn, args) =>
-              disallowCapInTypeArgs(tpt, fn.typeSymbol, args.map(TypeTree(_)))
+              disallowCapInTypeArgs(tpt, fn.typeSymbol, args.map(TypeTree(_)), thisPhase)
             case _ =>
         inNestedLevelUnless(cls.is(Module)):
           super.recheckClassDef(tree, impl, cls)
@@ -1008,40 +1013,12 @@ class CheckCaptures extends Recheck, SymTransformer:
           report.error(ex.getMessage.nn)
           tree.tpe
         finally curEnv = saved
-      if tree.isTerm then
-        if !ccConfig.useExistentials then
-          checkReachCapsIsolated(res.widen, tree.srcPos)
-        if !pt.isBoxedCapturing && pt != LhsProto then
-          markFree(res.boxedCaptureSet, tree.srcPos)
+      if tree.isTerm && !pt.isBoxedCapturing && pt != LhsProto then
+        markFree(res.boxedCaptureSet, tree.srcPos)
       res
 
     override def recheckFinish(tpe: Type, tree: Tree, pt: Type)(using Context): Type =
-      def needsUniversalCheck = tree match
-        case _: RefTree | _: Apply | _: TypeApply => tree.symbol.unboxesResult
-        case _: Try => true
-        case _ => false
-
-      object checkNotUniversal extends TypeTraverser:
-        def traverse(tp: Type) =
-         tp.dealias match
-          case wtp @ CapturingType(parent, refs) =>
-            if variance > 0 then
-              refs.disallowRootCapability: () =>
-                def part = if wtp eq tpe.widen then "" else i" in its part $wtp"
-                report.error(
-                  em"""The expression's type ${tpe.widen} is not allowed to capture the root capability `cap`$part.
-                    |This usually means that a capability persists longer than its allowed lifetime.""",
-                  tree.srcPos)
-            if !wtp.isBoxed then traverse(parent)
-          case tp =>
-            traverseChildren(tp)
-
-      if !ccConfig.useSealed
-          && !tpe.hasAnnotation(defn.UncheckedCapturesAnnot)
-          && needsUniversalCheck
-          && tpe.widen.isValueType
-      then
-        checkNotUniversal.traverse(tpe.widen)
+      checkNotUniversalInUnboxedResult(tpe, tree)
       super.recheckFinish(tpe, tree, pt)
     end recheckFinish
 
diff --git a/compiler/src/dotty/tools/dotc/cc/Existential.scala b/compiler/src/dotty/tools/dotc/cc/Existential.scala
index 732510789e28..d51ce1b08dbd 100644
--- a/compiler/src/dotty/tools/dotc/cc/Existential.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Existential.scala
@@ -333,10 +333,8 @@ object Existential:
         override def toString = "Wrap.inverse"
     end Wrap
 
-    if ccConfig.useExistentials then
-      val wrapped = apply(Wrap(_)(tp))
-      if needsWrap then wrapped else tp
-    else tp
+    val wrapped = apply(Wrap(_)(tp))
+    if needsWrap then wrapped else tp
   end mapCap
 
   def mapCapInResults(fail: Message => Unit)(using Context): TypeMap = new:

From adf6a257e44935016ded5a73a7df8949b1627624 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 2 Nov 2024 21:44:40 +0100
Subject: [PATCH 214/306] Refactoring: Use common code for all markFree
 variants

---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  |  1 +
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 28 +++++++++++++------
 tests/neg-custom-args/captures/capt1.check    |  8 +++---
 tests/neg-custom-args/captures/cc-this5.check |  2 +-
 tests/neg-custom-args/captures/eta.check      |  2 +-
 .../captures/exception-definitions.check      |  2 +-
 tests/neg-custom-args/captures/i15772.check   |  4 +--
 tests/neg-custom-args/captures/i16114.check   |  8 +++---
 .../neg-custom-args/captures/lazylists2.check |  4 +--
 .../captures/leaked-curried.check             |  4 +--
 tests/neg-custom-args/captures/try.check      |  4 +--
 11 files changed, 39 insertions(+), 28 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index 2dc2bbf77abe..8e684e212f3b 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -290,6 +290,7 @@ extension (tp: Type)
         case _: ThisType | NoPrefix =>
           tp1.symbol.is(Param) || tp1.symbol.is(ParamAccessor)
         case prefix => prefix.isParamPath
+    case _: ParamRef => true
     case _ => false
 
   /** If this is a unboxed capturing type with nonempty capture set, its boxed version.
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 8a7231866742..d35cbc3700e2 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -390,14 +390,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       markFree(sym, sym.termRef, pos)
 
     def markFree(sym: Symbol, ref: TermRef, pos: SrcPos)(using Context): Unit =
-      if sym.exists && ref.isTracked then
-        def recur(env: Env): Unit =
-          if env.isOpen && env.owner != sym.enclosure then
-            capt.println(i"Mark $sym with cs ${ref.captureSet} free in ${env.owner}")
-            checkElem(ref, env.captured, pos, provenance(env))
-            if !isOfNestedMethod(env) then
-              recur(nextEnvToCharge(env, _.owner != sym.enclosure))
-        recur(curEnv)
+      if sym.exists && ref.isTracked then markFree(ref.captureSet, 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
@@ -434,7 +427,24 @@ class CheckCaptures extends Recheck, SymTransformer:
               case ref =>
                 false
             if !isVisible then
-              c match
+              //println(i"out of scope: $c")
+              if ccConfig.deferredReaches then // avoid all locally bound capabilities
+                if c.isParamPath then
+                  c match
+                    case ReachCapability(_) | _: TypeRef =>
+                      checkUseDeclared(c, env, lastEnv)
+                    case _ =>
+                else
+                  val underlying = c match
+                    case ReachCapability(c1) =>
+                      CaptureSet.ofTypeDeeply(c1.widen)
+                    case _ =>
+                      CaptureSet.ofType(c.widen, followResult = false)
+                    capt.println(i"Widen reach $c to $underlying in ${env.owner}")
+                  underlying.disallowRootCapability: () =>
+                    report.error(em"Local capability $c in ${env.ownerString} cannot have `cap` as underlying capture set", pos)
+                  recur(underlying, env, lastEnv)
+              else c match // avoid only reach capabilities and capture sets
                 case ReachCapability(c1) =>
                   if c1.isParamPath then
                     checkUseDeclared(c, env, lastEnv)
diff --git a/tests/neg-custom-args/captures/capt1.check b/tests/neg-custom-args/captures/capt1.check
index 94103799d698..f63c55ca48c4 100644
--- a/tests/neg-custom-args/captures/capt1.check
+++ b/tests/neg-custom-args/captures/capt1.check
@@ -1,12 +1,12 @@
 -- Error: tests/neg-custom-args/captures/capt1.scala:6:11 --------------------------------------------------------------
 6 |  () => if x == null then y else y  // error
   |           ^
-  |           (x : C^) cannot be referenced here; it is not included in the allowed capture set {}
+  |           reference (x : C^) is not included in the allowed capture set {}
   |           of an enclosing function literal with expected type () -> C
 -- Error: tests/neg-custom-args/captures/capt1.scala:9:11 --------------------------------------------------------------
 9 |  () => if x == null then y else y  // error
   |           ^
-  |           (x : C^) cannot be referenced here; it is not included in the allowed capture set {}
+  |           reference (x : C^) is not included in the allowed capture set {}
   |           of an enclosing function literal with expected type Matchable
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:16:2 -----------------------------------------
 16 |  def f(y: Int) = if x == null then y else y  // error
@@ -41,8 +41,8 @@
 -- Error: tests/neg-custom-args/captures/capt1.scala:34:30 -------------------------------------------------------------
 34 |  val z2 = h[() -> Cap](() => x) // error // error
    |                              ^
-   |                            (x : C^) cannot be referenced here; it is not included in the allowed capture set {}
-   |                            of an enclosing function literal with expected type () -> box C^
+   |                              reference (x : C^) is not included in the allowed capture set {}
+   |                              of an enclosing function literal with expected type () -> box C^
 -- Error: tests/neg-custom-args/captures/capt1.scala:36:13 -------------------------------------------------------------
 36 |  val z3 = h[(() -> Cap) @retains(x)](() => x)(() => C())  // error
    |             ^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/neg-custom-args/captures/cc-this5.check b/tests/neg-custom-args/captures/cc-this5.check
index 8affe7005e2e..21b5b36e0574 100644
--- a/tests/neg-custom-args/captures/cc-this5.check
+++ b/tests/neg-custom-args/captures/cc-this5.check
@@ -1,7 +1,7 @@
 -- Error: tests/neg-custom-args/captures/cc-this5.scala:16:20 ----------------------------------------------------------
 16 |    def f = println(c)  // error
    |                    ^
-   |                    (c : Cap^) cannot be referenced here; it is not included in the allowed capture set {}
+   |                    reference (c : Cap^) is not included in the allowed capture set {}
    |                    of the enclosing class A
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/cc-this5.scala:21:15 -------------------------------------
 21 |    val x: A = this // error
diff --git a/tests/neg-custom-args/captures/eta.check b/tests/neg-custom-args/captures/eta.check
index 9850e54a7fdf..b7669e9b68ea 100644
--- a/tests/neg-custom-args/captures/eta.check
+++ b/tests/neg-custom-args/captures/eta.check
@@ -8,5 +8,5 @@
 -- Error: tests/neg-custom-args/captures/eta.scala:6:20 ----------------------------------------------------------------
 6 |         bar( () => f )  // error
   |                    ^
-  |                    (f : Proc^) cannot be referenced here; it is not included in the allowed capture set {}
+  |                    reference (f : Proc^) is not included in the allowed capture set {}
   |                    of an enclosing function literal with expected type () -> box () ->? Unit
diff --git a/tests/neg-custom-args/captures/exception-definitions.check b/tests/neg-custom-args/captures/exception-definitions.check
index 7f915ebd9833..3f2b15f312b9 100644
--- a/tests/neg-custom-args/captures/exception-definitions.check
+++ b/tests/neg-custom-args/captures/exception-definitions.check
@@ -5,7 +5,7 @@
 -- 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 the self type of class Err2
+  |            reference (c : Any^) is not included in the allowed capture set {} of the self type of class Err2
 -- Error: tests/neg-custom-args/captures/exception-definitions.scala:8:13 ----------------------------------------------
 8 |  class Err3(c: Any^) extends Exception // error
   |             ^
diff --git a/tests/neg-custom-args/captures/i15772.check b/tests/neg-custom-args/captures/i15772.check
index 0f8f0bf6eac5..67685d5663b8 100644
--- a/tests/neg-custom-args/captures/i15772.check
+++ b/tests/neg-custom-args/captures/i15772.check
@@ -1,7 +1,7 @@
 -- Error: tests/neg-custom-args/captures/i15772.scala:19:26 ------------------------------------------------------------
 19 |    val c : C^{x} = new C(x)  // error
    |                          ^
-   |                          (x : C^) cannot be referenced here; it is not included in the allowed capture set {}
+   |                          reference (x : C^) is not included in the allowed capture set {}
    |                          of an enclosing function literal with expected type () -> Int
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:20:46 ---------------------------------------
 20 |    val boxed1 : ((C^) => Unit) -> Unit = box1(c)  // error
@@ -13,7 +13,7 @@
 -- Error: tests/neg-custom-args/captures/i15772.scala:26:26 ------------------------------------------------------------
 26 |    val c : C^{x} = new C(x) // error
    |                          ^
-   |                          (x : C^) cannot be referenced here; it is not included in the allowed capture set {}
+   |                          reference (x : C^) is not included in the allowed capture set {}
    |                          of an enclosing function literal with expected type () -> Int
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:27:35 ---------------------------------------
 27 |    val boxed2 : Observe[C^] = box2(c)  // error
diff --git a/tests/neg-custom-args/captures/i16114.check b/tests/neg-custom-args/captures/i16114.check
index 3b9fbd40493f..745ccea1f905 100644
--- a/tests/neg-custom-args/captures/i16114.check
+++ b/tests/neg-custom-args/captures/i16114.check
@@ -6,7 +6,7 @@
 -- Error: tests/neg-custom-args/captures/i16114.scala:20:8 -------------------------------------------------------------
 20 |        fs  // error (limitation)
    |        ^^
-   |        (fs : Cap^) cannot be referenced here; it is not included in the allowed capture set {io}
+   |        reference (fs : Cap^) is not included in the allowed capture set {io}
    |        of an enclosing function literal with expected type Unit ->{io} Unit
 -- Error: tests/neg-custom-args/captures/i16114.scala:24:13 ------------------------------------------------------------
 24 |      expect[Cap^] { // error
@@ -16,7 +16,7 @@
 -- Error: tests/neg-custom-args/captures/i16114.scala:26:8 -------------------------------------------------------------
 26 |        io  // error (limitation)
    |        ^^
-   |        (io : Cap^) cannot be referenced here; it is not included in the allowed capture set {fs}
+   |        reference (io : Cap^) is not included in the allowed capture set {fs}
    |        of an enclosing function literal with expected type Unit ->{fs} Unit
 -- Error: tests/neg-custom-args/captures/i16114.scala:30:13 ------------------------------------------------------------
 30 |      expect[Cap^] {  // error
@@ -36,10 +36,10 @@
 -- Error: tests/neg-custom-args/captures/i16114.scala:40:8 -------------------------------------------------------------
 40 |        io.use()    // error
    |        ^^
-   |        (io : Cap^) cannot be referenced here; it is not included in the allowed capture set {}
+   |        reference (io : Cap^) is not included in the allowed capture set {}
    |        of an enclosing function literal with expected type Unit -> Unit
 -- Error: tests/neg-custom-args/captures/i16114.scala:41:8 -------------------------------------------------------------
 41 |        io          // error
    |        ^^
-   |        (io : Cap^) cannot be referenced here; it is not included in the allowed capture set {}
+   |        reference (io : Cap^) is not included in the allowed capture set {}
    |        of an enclosing function literal with expected type Unit -> Unit
diff --git a/tests/neg-custom-args/captures/lazylists2.check b/tests/neg-custom-args/captures/lazylists2.check
index 13b1da6eaf1c..d1883cc54718 100644
--- a/tests/neg-custom-args/captures/lazylists2.check
+++ b/tests/neg-custom-args/captures/lazylists2.check
@@ -25,11 +25,11 @@
 -- Error: tests/neg-custom-args/captures/lazylists2.scala:40:20 --------------------------------------------------------
 40 |      def head: B = f(xs.head)  // error
    |                    ^
-   |(f : A => B) cannot be referenced here; it is not included in the allowed capture set {xs} of the self type of class Mapped
+   |         reference (f : A => B) is not included in the allowed capture set {xs} of the self type of class Mapped
 -- Error: tests/neg-custom-args/captures/lazylists2.scala:41:48 --------------------------------------------------------
 41 |      def tail: LazyList[B]^{this}= xs.tail.map(f) // error
    |                                                ^
-   |(f : A => B) cannot be referenced here; it is not included in the allowed capture set {xs} of the self type of class Mapped
+   |         reference (f : A => B) is not included in the allowed capture set {xs} of the self type of class Mapped
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylists2.scala:45:4 ------------------------------------
 45 |    final class Mapped extends LazyList[B]:  // error
    |    ^
diff --git a/tests/neg-custom-args/captures/leaked-curried.check b/tests/neg-custom-args/captures/leaked-curried.check
index 63359e7bb8b8..be11aedd74ae 100644
--- a/tests/neg-custom-args/captures/leaked-curried.check
+++ b/tests/neg-custom-args/captures/leaked-curried.check
@@ -1,10 +1,10 @@
 -- Error: tests/neg-custom-args/captures/leaked-curried.scala:14:20 ----------------------------------------------------
 14 |        () => () => io // error
    |                    ^^
-   |           (io : Cap^) cannot be referenced here; it is not included in the allowed capture set {}
+   |           reference (io : Cap^) is not included in the allowed capture set {}
    |           of an enclosing function literal with expected type () -> () ->{io} (ex$7: caps.Exists) -> Cap^{ex$7}
 -- Error: tests/neg-custom-args/captures/leaked-curried.scala:17:20 ----------------------------------------------------
 17 |        () => () => io // error
    |                    ^^
-   |         (io : Cap^) cannot be referenced here; it is not included in the allowed capture set {}
+   |         reference (io : Cap^) is not included in the allowed capture set {}
    |         of an enclosing function literal with expected type () -> () ->{io} (ex$15: caps.Exists) -> Cap^{ex$15}
diff --git a/tests/neg-custom-args/captures/try.check b/tests/neg-custom-args/captures/try.check
index 9c49c444c82f..72604451472c 100644
--- a/tests/neg-custom-args/captures/try.check
+++ b/tests/neg-custom-args/captures/try.check
@@ -6,8 +6,8 @@
 -- Error: tests/neg-custom-args/captures/try.scala:30:65 ---------------------------------------------------------------
 30 |    (x: CanThrow[Exception]) => () => raise(new Exception)(using x) // error
    |                                                                 ^
-   |           (x : CanThrow[Exception]) cannot be referenced here; it is not included in the allowed capture set {}
-   |           of an enclosing function literal with expected type () ->? Nothing
+   |                               reference (x : CanThrow[Exception]) is not included in the allowed capture set {}
+   |                               of an enclosing function literal with expected type () ->? Nothing
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/try.scala:52:2 -------------------------------------------
 47 |val global: () -> Int = handle {
 48 |  (x: CanThrow[Exception]) =>

From 496c866106bf93cc12e1e375c38a37e2e2284903 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 3 Nov 2024 12:25:20 +0100
Subject: [PATCH 215/306] Fix dcs for invariant type parameters

Also: add test that reach capabilities are contained inside boxes
---
 .../src/dotty/tools/dotc/cc/CaptureSet.scala    |  6 ++++--
 tests/pos-custom-args/captures/boxed-use.scala  | 17 +++++++++++++++++
 2 files changed, 21 insertions(+), 2 deletions(-)
 create mode 100644 tests/pos-custom-args/captures/boxed-use.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
index cde0431e3e86..406d9b661fb3 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
@@ -1116,13 +1116,15 @@ object CaptureSet:
   /** The deep capture set of a type is the union of all covariant occurrences of
    *  capture sets. Nested existential sets are approximated with `cap`.
    *  NOTE: The traversal logic needs to be in sync with narrowCaps in CaptureOps, which
-   *  replaces caps with reach capabilties.
+   *  replaces caps with reach capabilties. The one exception to this is invariant
+   *  arguments. This have to be included to be conservative in dcs but must be
+   *  excluded in narrowCaps.
    */
   def ofTypeDeeply(tp: Type)(using Context): CaptureSet =
     val collect = new TypeAccumulator[CaptureSet]:
       val seen = util.HashSet[Symbol]()
       def apply(cs: CaptureSet, t: Type) =
-        if variance <= 0 then cs
+        if variance < 0 then cs
         else t.dealias match
           case t @ CapturingType(p, cs1) =>
             this(cs, p) ++ cs1
diff --git a/tests/pos-custom-args/captures/boxed-use.scala b/tests/pos-custom-args/captures/boxed-use.scala
new file mode 100644
index 000000000000..5dbdab7a6935
--- /dev/null
+++ b/tests/pos-custom-args/captures/boxed-use.scala
@@ -0,0 +1,17 @@
+class Box[A](val elem: A)
+class CoBox[+A](val elem: A)
+
+def applyAll[A](fs: Box[A => Unit], x: A): Box[() ->{fs*} Unit] =
+  Box(() => fs.elem(x))
+
+def applyAllCo[A](fs: CoBox[A => Unit], x: A): CoBox[() ->{fs*} Unit] =
+  CoBox(() => fs.elem(x))
+
+// Same with inferred result types
+def test =
+  def applyAll[A](fs: Box[A => Unit], x: A) =
+    Box(() => fs.elem(x))
+
+  def applyAllCo[A](fs: CoBox[A => Unit], x: A) =
+    CoBox(() => fs.elem(x))
+

From f4c09e3891005c5d404ef68dfb01afe965c68ac1 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 3 Nov 2024 23:54:44 +0100
Subject: [PATCH 216/306] Fix toFunctionType for methods containing reach
 capabilities in the result type

---
 .../src/dotty/tools/dotc/core/Types.scala     |  7 +++++--
 .../captures/depfun-reach.check               | 14 +++++++++++++
 .../captures/depfun-reach.scala               | 20 +++++++++++++++++++
 .../captures/gears-problem.scala              |  7 ++++++-
 4 files changed, 45 insertions(+), 3 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/depfun-reach.check
 create mode 100644 tests/neg-custom-args/captures/depfun-reach.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 87398000a461..95c3b025b3ce 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -38,8 +38,7 @@ import config.Printers.{core, typr, matchTypes}
 import reporting.{trace, Message}
 import java.lang.ref.WeakReference
 import compiletime.uninitialized
-import cc.{CapturingType, CaptureRef, CaptureSet, SingletonCaptureRef, isTrackableRef,
-           derivedCapturingType, isBoxedCapturing, isCaptureChecking, isRetains, isRetainsLike}
+import cc.*
 import CaptureSet.{CompareResult, IdempotentCaptRefMap, IdentityCaptRefMap}
 
 import scala.annotation.internal.sharable
@@ -4070,6 +4069,10 @@ object Types extends TypeUtils {
               range(defn.NothingType, atVariance(1)(apply(tp.underlying)))
             case CapturingType(_, _) =>
               mapOver(tp)
+            case ReachCapability(tp1) =>
+              apply(tp1) match
+                case tp1a: CaptureRef if tp1a.isTrackableRef => tp1a.reach
+                case _ => defn.captureRoot.termRef
             case AnnotatedType(parent, ann) if ann.refersToParamOf(thisLambdaType) =>
               val parent1 = mapOver(parent)
               if ann.symbol.isRetainsLike then
diff --git a/tests/neg-custom-args/captures/depfun-reach.check b/tests/neg-custom-args/captures/depfun-reach.check
new file mode 100644
index 000000000000..c1d7d05dc8d6
--- /dev/null
+++ b/tests/neg-custom-args/captures/depfun-reach.check
@@ -0,0 +1,14 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/depfun-reach.scala:13:4 ----------------------------------
+13 |    op // error
+   |    ^^
+   |    Found:    (xs: List[(X, box () ->{io} Unit)]) ->{op} List[box () ->{xs*} Unit]
+   |    Required: (xs: List[(X, box () ->{io} Unit)]) => List[() -> Unit]
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/depfun-reach.scala:20:60 ---------------------------------
+20 |  val b: (xs: List[() ->{io} Unit]) => List[() ->{} Unit] = a // error
+   |                                                            ^
+   |                                        Found:    (xs: List[box () ->{io} Unit]) ->{a} List[box () ->{xs*} Unit]
+   |                                        Required: (xs: List[box () ->{io} Unit]) => List[() -> Unit]
+   |
+   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/depfun-reach.scala b/tests/neg-custom-args/captures/depfun-reach.scala
new file mode 100644
index 000000000000..94b10f7dbcdb
--- /dev/null
+++ b/tests/neg-custom-args/captures/depfun-reach.scala
@@ -0,0 +1,20 @@
+import language.experimental.captureChecking
+import caps.cap
+
+def test(io: Object^, async: Object^) =
+  def compose(op: List[(() ->{cap} Unit, () ->{cap} Unit)]): List[() ->{op*} Unit] =
+    List(() => op.foreach((f,g) => { f(); g() }))
+
+  def compose1(op: List[(() ->{async} Unit, () ->{io} Unit)]): List[() ->{op*} Unit] =
+    compose(op)
+
+  def foo[X](op: (xs: List[(X, () ->{io} Unit)]) => List[() ->{xs*} Unit])
+               : (xs: List[(X, () ->{io} Unit)]) => List[() ->{} Unit] =
+    op // error
+
+  def boom(op: List[(() ->{async} Unit, () ->{io} Unit)]): List[() ->{} Unit] =
+    foo(compose1)(op)
+
+def test2(io: Object^) =
+  val a: (xs: List[() ->{io} Unit]) => List[() ->{xs*} Unit] = ???
+  val b: (xs: List[() ->{io} Unit]) => List[() ->{} Unit] = a // error
diff --git a/tests/pos-custom-args/captures/gears-problem.scala b/tests/pos-custom-args/captures/gears-problem.scala
index c6ef72bc421e..531c59d9fe7d 100644
--- a/tests/pos-custom-args/captures/gears-problem.scala
+++ b/tests/pos-custom-args/captures/gears-problem.scala
@@ -16,4 +16,9 @@ extension [T](@use fs: Seq[Future[T]^])
     val collector: Collector[T]{val futures: Seq[Future[T]^{fs*}]}
        = Collector(fs)
     // val ch = collector.results // also errors
-    val fut: Future[T]^{fs*} = collector.results.read().right.get // found ...^{caps.cap}
\ No newline at end of file
+    val fut: Future[T]^{fs*} = collector.results.read().right.get // found ...^{caps.cap}
+
+    val ch = collector.results
+    val item = ch.read()
+    val r = item.right
+    val fut2: Future[T]^{fs*} = r.get
\ No newline at end of file

From c4c69b0d7749c84411b622001e835aeb727031db Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 5 Nov 2024 19:28:18 +0100
Subject: [PATCH 217/306] Expand criterion when to not check inferred types a
 bit

---
 compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index d35cbc3700e2..628217e27164 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -894,6 +894,7 @@ class CheckCaptures extends Recheck, SymTransformer:
 
       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.privateWithin == sym.effectiveOwner
         || 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.

From 91da9fbf135ad07193395e97a950125ef058c637 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 5 Nov 2024 19:29:34 +0100
Subject: [PATCH 218/306] Be more careful computing underlying types of reach
 capabilities

We can use the dcs only if there are no type variables.
---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  | 23 ++++--
 .../src/dotty/tools/dotc/cc/CaptureSet.scala  | 11 ++-
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 74 ++++++++++---------
 .../src/dotty/tools/dotc/core/SymUtils.scala  |  3 +
 .../captures/gears-problem-1.scala}           |  2 +-
 .../captures/gears-problem.check              | 15 ++++
 .../captures/gears-problem.scala              |  4 +-
 .../captures/unsound-reach-7.scala            | 15 ++++
 .../neg-custom-args/captures/use-capset.check | 19 +++++
 .../neg-custom-args/captures/use-capset.scala | 16 ++++
 .../captures/gears-problem-poly.scala         | 29 ++++++++
 11 files changed, 165 insertions(+), 46 deletions(-)
 rename tests/{pos/gears-probem-1.scala => neg-custom-args/captures/gears-problem-1.scala} (87%)
 create mode 100644 tests/neg-custom-args/captures/gears-problem.check
 rename tests/{pos-custom-args => neg-custom-args}/captures/gears-problem.scala (90%)
 create mode 100644 tests/neg-custom-args/captures/unsound-reach-7.scala
 create mode 100644 tests/neg-custom-args/captures/use-capset.check
 create mode 100644 tests/neg-custom-args/captures/use-capset.scala
 create mode 100644 tests/pos-custom-args/captures/gears-problem-poly.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index 8e684e212f3b..5508a5a3d0f6 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -220,8 +220,8 @@ extension (tp: Type)
    *  a singleton capability `x` or a reach capability `x*`, the deep capture
    *  set can be narrowed to`{x*}`.
    */
-  def deepCaptureSet(using Context): CaptureSet =
-    val dcs = CaptureSet.ofTypeDeeply(tp.widen.stripCapturing)
+  def deepCaptureSet(includeTypevars: Boolean)(using Context): CaptureSet =
+    val dcs = CaptureSet.ofTypeDeeply(tp.widen.stripCapturing, includeTypevars)
     if dcs.isAlwaysEmpty then tp.captureSet
     else tp match
       case tp @ ReachCapability(_) =>
@@ -231,6 +231,9 @@ extension (tp: Type)
       case _ =>
         tp.captureSet ++ dcs
 
+  def deepCaptureSet(using Context): CaptureSet =
+    deepCaptureSet(includeTypevars = false)
+
   /** A type capturing `ref` */
   def capturing(ref: CaptureRef)(using Context): Type =
     if tp.captureSet.accountsFor(ref) then tp
@@ -593,9 +596,7 @@ extension (sym: Symbol)
   def isRefiningParamAccessor(using Context): Boolean =
     sym.is(ParamAccessor)
     && {
-      val param = sym.owner.primaryConstructor.paramSymss
-        .nestedFind(_.name == sym.name)
-        .getOrElse(NoSymbol)
+      val param = sym.owner.primaryConstructor.paramNamed(sym.name)
       !param.hasAnnotation(defn.ConstructorOnlyAnnot)
       && !param.hasAnnotation(defn.UntrackedCapturesAnnot)
     }
@@ -603,6 +604,18 @@ extension (sym: Symbol)
   def hasTrackedParts(using Context): Boolean =
     !CaptureSet.ofTypeDeeply(sym.info).isAlwaysEmpty
 
+  /** `sym` is annotated @use or it is a type parameter with a matching
+   *  @use-annotated term parameter that contains `sym` in its deep capture set.
+   */
+  def isUseParam(using Context): Boolean =
+    sym.hasAnnotation(defn.UseAnnot)
+    || sym.is(TypeParam)
+        && sym.owner.rawParamss.nestedExists: param =>
+            param.is(TermParam) && param.hasAnnotation(defn.UseAnnot)
+            && param.info.deepCaptureSet.elems.exists:
+                case c: TypeRef => c.symbol == sym
+                case _ => false
+
 extension (tp: AnnotatedType)
   /** Is this a boxed capturing type? */
   def isBoxed(using Context): Boolean = tp.annot match
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
index 406d9b661fb3..899045843cbf 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
@@ -1064,8 +1064,9 @@ object CaptureSet:
     case ref: (TermRef | TermParamRef) if ref.isMaxCapability =>
       if ref.isTrackableRef then ref.singletonCaptureSet
       else CaptureSet.universal
-    case ReachCapability(ref1) => ref1.widen.deepCaptureSet
-      .showing(i"Deep capture set of $ref: ${ref1.widen} = $result", capt)
+    case ReachCapability(ref1) =>
+      ref1.widen.deepCaptureSet(includeTypevars = true)
+        .showing(i"Deep capture set of $ref: ${ref1.widen} = ${result}", capt)
     case _ => ofType(ref.underlying, followResult = true)
 
   /** Capture set of a type */
@@ -1120,7 +1121,7 @@ object CaptureSet:
    *  arguments. This have to be included to be conservative in dcs but must be
    *  excluded in narrowCaps.
    */
-  def ofTypeDeeply(tp: Type)(using Context): CaptureSet =
+  def ofTypeDeeply(tp: Type, includeTypevars: Boolean = false)(using Context): CaptureSet =
     val collect = new TypeAccumulator[CaptureSet]:
       val seen = util.HashSet[Symbol]()
       def apply(cs: CaptureSet, t: Type) =
@@ -1132,7 +1133,9 @@ object CaptureSet:
             this(cs, parent)
           case t: TypeRef if t.symbol.isAbstractOrParamType && !seen.contains(t.symbol) =>
             seen += t.symbol
-            this(cs, t.info.bounds.hi)
+            val upper = t.info.bounds.hi
+            if includeTypevars && upper.isExactlyAny then CaptureSet.universal
+            else this(cs, t.info.bounds.hi)
           case t @ FunctionOrMethod(args, res @ Existential(_, _))
           if args.forall(_.isAlwaysPure) =>
             this(cs, Existential.toCap(res))
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 628217e27164..32271ecacc41 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -185,34 +185,6 @@ object CheckCaptures:
     if ccConfig.useSealed then check.traverse(tp)
   end disallowRootCapabilitiesIn
 
-  /** Under the sealed policy, disallow the root capability in type arguments.
-   *  Type arguments come either from a TypeApply node or from an AppliedType
-   *  which represents a trait parent in a template.
-   *  @param  fn   the type application, of type TypeApply or TypeTree
-   *  @param  sym  the constructor symbol (could be a method or a val or a class)
-   *  @param  args the type arguments
-   */
-  private def disallowCapInTypeArgs(fn: Tree, sym: Symbol, args: List[Tree], thisPhase: Phase)(using Context): Unit =
-    def isExempt = sym.isTypeTestOrCast || sym == defn.Compiletime_erasedValue
-    if ccConfig.useSealed && !isExempt then
-      val paramNames = atPhase(thisPhase.prev):
-        fn.tpe.widenDealias match
-          case tl: TypeLambda => tl.paramNames
-          case ref: AppliedType if ref.typeSymbol.isClass => ref.typeSymbol.typeParams.map(_.name)
-          case t =>
-            println(i"parent type: $t")
-            args.map(_ => EmptyTypeName)
-      for case (arg: TypeTree, pname) <- args.lazyZip(paramNames) do
-        def where = if sym.exists then i" in an argument of $sym" else ""
-        val (addendum, pos) =
-          if arg.isInferred
-          then ("\nThis is often caused by a local capability$where\nleaking as part of its result.", fn.srcPos)
-          else if arg.span.exists then ("", arg.srcPos)
-          else ("", fn.srcPos)
-        disallowRootCapabilitiesIn(arg.knownType, NoSymbol,
-          i"Type variable $pname of $sym", "be instantiated to", addendum, pos)
-  end disallowCapInTypeArgs
-
   /** If we are not under the sealed policy, and a tree is an application that unboxes
    *  its result or is a try, check that the tree's type does not have covariant universal
    *  capabilities.
@@ -409,14 +381,14 @@ class CheckCaptures extends Recheck, SymTransformer:
         if lastEnv != null && env.nestedClosure.exists && env.nestedClosure == lastEnv.owner then
           () // access is from a nested closure, so it's OK
         else c.pathRoot match
-          case ref: NamedType if !ref.symbol.hasAnnotation(defn.UseAnnot) =>
+          case ref: NamedType if !ref.symbol.isUseParam =>
             val what = if ref.isType then "Capture set parameter" else "Local reach capability"
             report.error(
               em"""$what $c leaks into capture scope of ${env.ownerString}.
                   |To allow this, the ${ref.symbol} should be declared with a @use annotation""", pos)
           case _ =>
 
-      def recur(cs: CaptureSet, env: Env, lastEnv: Env | Null)(using Context): Unit =
+      def recur(cs: CaptureSet, env: Env, lastEnv: Env | Null): Unit =
         if env.isOpen && !env.owner.isStaticOwner && !cs.isAlwaysEmpty then
           // Only captured references that are visible from the environment
           // should be included.
@@ -480,6 +452,40 @@ class CheckCaptures extends Recheck, SymTransformer:
       case _ =>
         if sym.exists && curEnv.isOpen then markFree(capturedVars(sym), pos)
 
+    /** Under the sealed policy, disallow the root capability in type arguments.
+     *  Type arguments come either from a TypeApply node or from an AppliedType
+     *  which represents a trait parent in a template. Also, if a corresponding
+     *  formal type parameter is declared or implied @use, charge the deep capture
+     *  set of the argument to the environent.
+     *  @param  fn   the type application, of type TypeApply or TypeTree
+     *  @param  sym  the constructor symbol (could be a method or a val or a class)
+     *  @param  args the type arguments
+     */
+    def disallowCapInTypeArgs(fn: Tree, sym: Symbol, args: List[Tree])(using Context): Unit =
+      def isExempt = sym.isTypeTestOrCast || sym == defn.Compiletime_erasedValue
+      if ccConfig.useSealed && !isExempt then
+        val paramNames = atPhase(thisPhase.prev):
+          fn.tpe.widenDealias match
+            case tl: TypeLambda => tl.paramNames
+            case ref: AppliedType if ref.typeSymbol.isClass => ref.typeSymbol.typeParams.map(_.name)
+            case t =>
+              println(i"parent type: $t")
+              args.map(_ => EmptyTypeName)
+
+        for case (arg: TypeTree, pname) <- args.lazyZip(paramNames) do
+          def where = if sym.exists then i" in an argument of $sym" else ""
+          val (addendum, pos) =
+            if arg.isInferred
+            then ("\nThis is often caused by a local capability$where\nleaking as part of its result.", fn.srcPos)
+            else if arg.span.exists then ("", arg.srcPos)
+            else ("", fn.srcPos)
+          disallowRootCapabilitiesIn(arg.knownType, NoSymbol,
+            i"Type variable $pname of $sym", "be instantiated to", addendum, pos)
+
+          val param = fn.symbol.paramNamed(pname)
+          if param.isUseParam then markFree(arg.knownType.deepCaptureSet, pos)
+    end disallowCapInTypeArgs
+
     override def recheckIdent(tree: Ident, pt: Type)(using Context): Type =
       val sym = tree.symbol
       if sym.is(Method) then
@@ -558,8 +564,8 @@ class CheckCaptures extends Recheck, SymTransformer:
      */
     override def prepareFunction(funtpe: MethodType, meth: Symbol)(using Context): MethodType =
       val paramInfosWithUses = funtpe.paramInfos.zipWithConserve(funtpe.paramNames): (formal, pname) =>
-        val paramOpt = meth.rawParamss.nestedFind(_.name == pname)
-        paramOpt.flatMap(_.getAnnotation(defn.UseAnnot)) match
+        val param = meth.paramNamed(pname)
+        param.getAnnotation(defn.UseAnnot) match
           case Some(ann) => AnnotatedType(formal, ann)
           case _ => formal
       funtpe.derivedLambdaType(paramInfos = paramInfosWithUses)
@@ -725,7 +731,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       val meth = tree.fun match
         case fun @ Select(qual, nme.apply) => qual.symbol.orElse(fun.symbol)
         case fun => fun.symbol
-      disallowCapInTypeArgs(tree.fun, meth, tree.args, thisPhase)
+      disallowCapInTypeArgs(tree.fun, meth, tree.args)
       val res = Existential.toCap(super.recheckTypeApply(tree, pt))
       includeCallCaptures(tree.symbol, res, tree.srcPos)
       checkContains(tree)
@@ -956,7 +962,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         for case tpt: TypeTree <- impl.parents do
           tpt.tpe match
             case AppliedType(fn, args) =>
-              disallowCapInTypeArgs(tpt, fn.typeSymbol, args.map(TypeTree(_)), thisPhase)
+              disallowCapInTypeArgs(tpt, fn.typeSymbol, args.map(TypeTree(_)))
             case _ =>
         inNestedLevelUnless(cls.is(Module)):
           super.recheckClassDef(tree, impl, cls)
diff --git a/compiler/src/dotty/tools/dotc/core/SymUtils.scala b/compiler/src/dotty/tools/dotc/core/SymUtils.scala
index 3a97a0053dbd..1a762737d52f 100644
--- a/compiler/src/dotty/tools/dotc/core/SymUtils.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymUtils.scala
@@ -271,6 +271,9 @@ class SymUtils:
       self.owner.info.decl(fieldName).suchThat(!_.is(Method)).symbol
     }
 
+    def paramNamed(name: Name)(using Context): Symbol =
+      self.rawParamss.nestedFind(_.name == name).getOrElse(NoSymbol)
+
     /** Is this symbol a constant expression final val?
      *
      *  This is the case if all of the following are true:
diff --git a/tests/pos/gears-probem-1.scala b/tests/neg-custom-args/captures/gears-problem-1.scala
similarity index 87%
rename from tests/pos/gears-probem-1.scala
rename to tests/neg-custom-args/captures/gears-problem-1.scala
index d363515afece..515aecd468f6 100644
--- a/tests/pos/gears-probem-1.scala
+++ b/tests/neg-custom-args/captures/gears-problem-1.scala
@@ -22,4 +22,4 @@ extension [T](@use fs: Seq[Future[T]^])
     val collector//: Collector[T]{val futures: Seq[Future[T]^{fs*}]}
        = Collector(fs)
     // val ch = collector.results // also errors
-    val fut: Future[T]^{fs*} = collector.results.read().get // found ...^{caps.cap}
\ No newline at end of file
+    val fut: Future[T]^{fs*} = collector.results.read().get // error
diff --git a/tests/neg-custom-args/captures/gears-problem.check b/tests/neg-custom-args/captures/gears-problem.check
new file mode 100644
index 000000000000..eb37feb6d568
--- /dev/null
+++ b/tests/neg-custom-args/captures/gears-problem.check
@@ -0,0 +1,15 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/gears-problem.scala:19:62 --------------------------------
+19 |    val fut: Future[T]^{fs*} = collector.results.read().right.get // error
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                               Found:    Future[T]^{collector.futures*}
+   |                               Required: Future[T]^{fs*}
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/gears-problem.scala:24:34 --------------------------------
+24 |    val fut2: Future[T]^{fs*} = r.get // error
+   |                                ^^^^^
+   |                                Found:    Future[box T^?]^{collector.futures*}
+   |                                Required: Future[T]^{fs*}
+   |
+   | longer explanation available when compiling with `-explain`
+there were 4 deprecation warnings; re-run with -deprecation for details
diff --git a/tests/pos-custom-args/captures/gears-problem.scala b/tests/neg-custom-args/captures/gears-problem.scala
similarity index 90%
rename from tests/pos-custom-args/captures/gears-problem.scala
rename to tests/neg-custom-args/captures/gears-problem.scala
index 531c59d9fe7d..8dcdaabb2100 100644
--- a/tests/pos-custom-args/captures/gears-problem.scala
+++ b/tests/neg-custom-args/captures/gears-problem.scala
@@ -16,9 +16,9 @@ extension [T](@use fs: Seq[Future[T]^])
     val collector: Collector[T]{val futures: Seq[Future[T]^{fs*}]}
        = Collector(fs)
     // val ch = collector.results // also errors
-    val fut: Future[T]^{fs*} = collector.results.read().right.get // found ...^{caps.cap}
+    val fut: Future[T]^{fs*} = collector.results.read().right.get // error
 
     val ch = collector.results
     val item = ch.read()
     val r = item.right
-    val fut2: Future[T]^{fs*} = r.get
\ No newline at end of file
+    val fut2: Future[T]^{fs*} = r.get // error
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/unsound-reach-7.scala b/tests/neg-custom-args/captures/unsound-reach-7.scala
new file mode 100644
index 000000000000..df345cdf7f6d
--- /dev/null
+++ b/tests/neg-custom-args/captures/unsound-reach-7.scala
@@ -0,0 +1,15 @@
+import language.experimental.captureChecking
+import caps.{cap, use}
+
+trait IO
+trait Async
+
+def main(io: IO^, async: Async^) =
+  def bad[X](ops: List[(X, () ->{io} Unit)])(f: () ->{ops*} Unit): () ->{io} Unit = f // error
+  def runOps(@use ops: List[(() => Unit, () => Unit)]): () ->{ops*} Unit =
+    () => ops.foreach((f1, f2) => { f1(); f2() })
+  def delayOps(@use ops: List[(() ->{async} Unit, () ->{io} Unit)]): () ->{io} Unit =
+    val runner: () ->{ops*} Unit = runOps(ops)
+    val badRunner: () ->{io} Unit = bad[() ->{async} Unit](ops)(runner)
+      // it uses both async and io, but we losed track of async.
+    badRunner
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/use-capset.check b/tests/neg-custom-args/captures/use-capset.check
new file mode 100644
index 000000000000..d94ff90cddb8
--- /dev/null
+++ b/tests/neg-custom-args/captures/use-capset.check
@@ -0,0 +1,19 @@
+-- Error: tests/neg-custom-args/captures/use-capset.scala:7:50 ---------------------------------------------------------
+7 |private def g[C^] = (xs: List[Object^{C^}]) => xs.head // error
+  |                                               ^^^^^^^
+  |                                               Capture set parameter C leaks into capture scope of method g.
+  |                                               To allow this, the type C should be declared with a @use annotation
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/use-capset.scala:13:22 -----------------------------------
+13 |  val _: () -> Unit = h // error: should be ->{io}
+   |                      ^
+   |                      Found:    (h : () ->{io} Unit)
+   |                      Required: () -> Unit
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/use-capset.scala:15:50 -----------------------------------
+15 |  val _: () -> List[Object^{io}] -> Object^{io} = h2 // error, should be ->{io}
+   |                                                  ^^
+   |                     Found:    () ->? (x$0: List[box Object^{io}]^{}) ->{io} (ex$13: caps.Exists) -> Object^{io}
+   |                     Required: () -> List[box Object^{io}] -> Object^{io}
+   |
+   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/use-capset.scala b/tests/neg-custom-args/captures/use-capset.scala
new file mode 100644
index 000000000000..6010e955f867
--- /dev/null
+++ b/tests/neg-custom-args/captures/use-capset.scala
@@ -0,0 +1,16 @@
+import caps.{use, CapSet}
+
+
+
+def f[C^](@use xs: List[Object^{C^}]): Unit = ???
+
+private def g[C^] = (xs: List[Object^{C^}]) => xs.head // error
+
+private def g2[@use C^] = (xs: List[Object^{C^}]) => xs.head // ok
+
+def test(io: Object^)(@use xs: List[Object^{io}]): Unit =
+  val h = () => f(xs)
+  val _: () -> Unit = h // error: should be ->{io}
+  val h2 = () => g[CapSet^{io}]
+  val _: () -> List[Object^{io}] -> Object^{io} = h2 // error, should be ->{io}
+
diff --git a/tests/pos-custom-args/captures/gears-problem-poly.scala b/tests/pos-custom-args/captures/gears-problem-poly.scala
new file mode 100644
index 000000000000..fdbcf37a35a6
--- /dev/null
+++ b/tests/pos-custom-args/captures/gears-problem-poly.scala
@@ -0,0 +1,29 @@
+import language.experimental.captureChecking
+import caps.{use, CapSet}
+
+trait Future[+T]:
+  def await: T
+
+trait Channel[+T]:
+  def read(): Ok[T]
+
+class Collector[T, C^](val futures: Seq[Future[T]^{C^}]):
+  val results: Channel[Future[T]^{C^}] = ???
+end Collector
+
+class Result[+T, +E]:
+  def get: T = ???
+
+case class Err[+E](e: E) extends Result[Nothing, E]
+case class Ok[+T](x: T) extends Result[T, Nothing]
+
+extension [T, C^](@use fs: Seq[Future[T]^{C^}])
+  def awaitAllPoly =
+    val collector = Collector(fs)
+    val fut: Future[T]^{C^} = collector.results.read().get
+
+extension [T](@use fs: Seq[Future[T]^])
+  def awaitAll = fs.awaitAllPoly
+
+def awaitExplicit[T](@use fs: Seq[Future[T]^]): Unit =
+  awaitAllPoly[T, CapSet^{fs*}](fs)

From 34e947ac91d11fba07464487b0be9cee83eeadf3 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 5 Nov 2024 21:42:51 +0100
Subject: [PATCH 219/306] Polish code of markFree

---
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 88 +++++++++++--------
 1 file changed, 49 insertions(+), 39 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 32271ecacc41..f1d4a55711e3 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -388,6 +388,52 @@ class CheckCaptures extends Recheck, SymTransformer:
                   |To allow this, the ${ref.symbol} should be declared with a @use annotation""", pos)
           case _ =>
 
+      /** Avoid locally defined capability by charging the underlying type
+       *  (which may not be cap). This scheme applies only under the deferredReaches setting.
+       */
+      def avoidLocalCapability(c: CaptureRef, env: Env, lastEnv: Env | Null): Unit =
+        if c.isParamPath then
+          c match
+            case ReachCapability(_) | _: TypeRef =>
+              checkUseDeclared(c, env, lastEnv)
+            case _ =>
+        else
+          val underlying = c match
+            case ReachCapability(c1) =>
+              CaptureSet.ofTypeDeeply(c1.widen)
+            case _ =>
+              CaptureSet.ofType(c.widen, followResult = false)
+            capt.println(i"Widen reach $c to $underlying in ${env.owner}")
+          underlying.disallowRootCapability: () =>
+            report.error(em"Local capability $c in ${env.ownerString} cannot have `cap` as underlying capture set", pos)
+          recur(underlying, env, lastEnv)
+
+      /** Avoid locally defined capability if it is a reach capability or capture set
+       *  parameter. This is the default.
+       */
+      def avoidLocalReachCapability(c: CaptureRef, env: Env): Unit = c match
+        case ReachCapability(c1) =>
+          if c1.isParamPath then
+            checkUseDeclared(c, env, null)
+          else
+            // When a reach capabilty x* where `x` is not a parameter goes out
+            // of scope, we need to continue with `x`'s underlying deep capture set.
+            // It is an error if that set contains cap.
+            // The same is not an issue for normal capabilities since in a local
+            // definition `val x = e`, the capabilities of `e` have already been charged.
+            // Note: It's not true that the underlying capture set of a reach capability
+            // is always cap. Reach capabilities over paths depend on the prefix, which
+            // might turn a cap into something else.
+            // The path-use.scala neg test contains an example.
+            val underlying = CaptureSet.ofTypeDeeply(c1.widen)
+            capt.println(i"Widen reach $c to $underlying in ${env.owner}")
+            underlying.disallowRootCapability: () =>
+              report.error(em"Local reach capability $c leaks into capture scope of ${env.ownerString}", pos)
+            recur(underlying, env, null)
+        case c: TypeRef if c.isParamPath =>
+          checkUseDeclared(c, env, null)
+        case _ =>
+
       def recur(cs: CaptureSet, env: Env, lastEnv: Env | Null): Unit =
         if env.isOpen && !env.owner.isStaticOwner && !cs.isAlwaysEmpty then
           // Only captured references that are visible from the environment
@@ -399,45 +445,9 @@ class CheckCaptures extends Recheck, SymTransformer:
               case ref =>
                 false
             if !isVisible then
-              //println(i"out of scope: $c")
-              if ccConfig.deferredReaches then // avoid all locally bound capabilities
-                if c.isParamPath then
-                  c match
-                    case ReachCapability(_) | _: TypeRef =>
-                      checkUseDeclared(c, env, lastEnv)
-                    case _ =>
-                else
-                  val underlying = c match
-                    case ReachCapability(c1) =>
-                      CaptureSet.ofTypeDeeply(c1.widen)
-                    case _ =>
-                      CaptureSet.ofType(c.widen, followResult = false)
-                    capt.println(i"Widen reach $c to $underlying in ${env.owner}")
-                  underlying.disallowRootCapability: () =>
-                    report.error(em"Local capability $c in ${env.ownerString} cannot have `cap` as underlying capture set", pos)
-                  recur(underlying, env, lastEnv)
-              else c match // avoid only reach capabilities and capture sets
-                case ReachCapability(c1) =>
-                  if c1.isParamPath then
-                    checkUseDeclared(c, env, lastEnv)
-                  else
-                    // When a reach capabilty x* where `x` is not a parameter goes out
-                    // of scope, we need to continue with `x`'s underlying deep capture set.
-                    // It is an error if that set contains cap.
-                    // The same is not an issue for normal capabilities since in a local
-                    // definition `val x = e`, the capabilities of `e` have already been charged.
-                    // Note: It's not true that the underlying capture set of a reach capability
-                    // is always cap. Reach capabilities over paths depend on the prefix, which
-                    // might turn a cap into something else.
-                    // The path-use.scala neg test contains an example.
-                    val underlying = CaptureSet.ofTypeDeeply(c1.widen)
-                    capt.println(i"Widen reach $c to $underlying in ${env.owner}")
-                    underlying.disallowRootCapability: () =>
-                      report.error(em"Local reach capability $c leaks into capture scope of ${env.ownerString}", pos)
-                    recur(underlying, env, lastEnv)
-                case c: TypeRef if c.isParamPath =>
-                  checkUseDeclared(c, env, lastEnv)
-                case _ =>
+              if ccConfig.deferredReaches
+              then avoidLocalCapability(c, env, lastEnv)
+              else avoidLocalReachCapability(c, env)
             isVisible
           checkSubset(included, env.captured, pos, provenance(env))
           capt.println(i"Include call or box capture $included from $cs in ${env.owner} --> ${env.captured}")

From eb0577f8e955489775c887743854cf131a90e3ba Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Fri, 8 Nov 2024 15:41:40 +0100
Subject: [PATCH 220/306] Revert change to Iterator

The additional purity in the asInstanceOf target is not needed
---
 scala2-library-cc/src/scala/collection/Iterator.scala | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/scala2-library-cc/src/scala/collection/Iterator.scala b/scala2-library-cc/src/scala/collection/Iterator.scala
index 22632d738199..7d5af9f021dc 100644
--- a/scala2-library-cc/src/scala/collection/Iterator.scala
+++ b/scala2-library-cc/src/scala/collection/Iterator.scala
@@ -1159,8 +1159,7 @@ object Iterator extends IterableFactory[Iterator] {
         // If we advanced the current iterator to a ConcatIterator, merge it into this one
         @tailrec def merge(): Unit =
           if (current.isInstanceOf[ConcatIterator[_]]) {
-            val c: ConcatIterator[A] { val from: Iterator[A] }
-               = current.asInstanceOf
+            val c: ConcatIterator[A] = current.asInstanceOf
             current = c.current.asInstanceOf // !!! CC unsafe op
             currentHasNextChecked = c.currentHasNextChecked
             if (c.tail != null) {

From 2b51ee98241c07153f3a6fddbc4ca2174b94332b Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Fri, 8 Nov 2024 17:01:43 +0100
Subject: [PATCH 221/306] Document and polish CheckCaptures

---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  |   4 -
 .../src/dotty/tools/dotc/cc/CaptureSet.scala  |   4 +-
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 532 +++++++++++-------
 tests/pos-custom-args/captures/vars1.scala    |   2 +-
 4 files changed, 326 insertions(+), 216 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index 5508a5a3d0f6..eef1b5caacd1 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -127,10 +127,6 @@ end CCState
 def ccState(using Context) =
   Phases.checkCapturesPhase.asInstanceOf[CheckCaptures].ccState1
 
-class NoCommonRoot(rs: Symbol*)(using Context) extends Exception(
-  i"No common capture root nested in ${rs.mkString(" and ")}"
-)
-
 extension (tree: Tree)
 
   /** Map tree with CaptureRef type to its type,
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
index 899045843cbf..675b00a09ff5 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
@@ -185,10 +185,12 @@ sealed abstract class CaptureSet extends Showable:
 
   /** 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`.
+   *  every element currently known to be in `cs1`, and the same is not true in reverse
+   *  when we compare elements of cs2 vs cs1.
    */
   def mightSubcapture(that: CaptureSet)(using Context): Boolean =
     elems.forall(that.mightAccountFor)
+    && !that.elems.forall(this.mightAccountFor)
 
   /** The subcapturing test.
    *  @param frozen   if true, no new variables or dependent sets are allowed to
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index f1d4a55711e3..41a35cb52d39 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -39,10 +39,12 @@ object CheckCaptures:
     case Boxed          // environment is inside a box (in which case references are not counted)
 
   /** A class describing environments.
-   *  @param owner     the current owner
-   *  @param kind      the environment's kind
-   *  @param captured  the capture set containing all references to tracked free variables outside of boxes
-   *  @param outer0    the next enclosing environment
+   *  @param owner         the current owner
+   *  @param kind          the environment's kind
+   *  @param captured      the capture set containing all references to tracked free variables outside of boxes
+   *  @param outer0        the next enclosing environment
+   *  @param nestedClosure under deferredReaches: If this is an env of a method with an anonymous function or
+   *                       anonymous class as RHS, the symbol of that function or class. NoSymbol in all other cases.
    */
   case class Env(
       owner: Symbol,
@@ -88,6 +90,9 @@ object CheckCaptures:
           mapOver(tp)
   end SubstParamsMap
 
+  /** Used for substituting parameters in a special case: when all actual arguments
+   *  are mutually distinct capabilities.
+   */
   final class SubstParamsBiMap(from: LambdaType, to: List[Type])(using Context)
   extends BiTypeMap:
     thisMap =>
@@ -240,6 +245,22 @@ class CheckCaptures extends Recheck, SymTransformer:
 
   class CaptureChecker(ictx: Context) extends Rechecker(ictx):
 
+    /** The current environment */
+    private val rootEnv: Env = inContext(ictx):
+      Env(defn.RootClass, EnvKind.Regular, CaptureSet.empty, null)
+    private var curEnv = rootEnv
+
+    /** Currently checked closures and their expected types, used for error reporting */
+    private var openClosures: List[(Symbol, Type)] = Nil
+
+    private val myCapturedVars: util.EqHashMap[Symbol, CaptureSet] = EqHashMap()
+
+    /** A list of actions to perform at postCheck. The reason to defer these actions
+     *  is that it is sometimes better for type inference to not constrain too early
+     *  with a checkConformsExpr.
+     */
+    private var todoAtPostCheck = new mutable.ListBuffer[() => Unit]
+
     override def keepType(tree: Tree) =
       super.keepType(tree)
       || tree.isInstanceOf[Try]  // type of `try` needs tp be checked for * escapes
@@ -271,10 +292,11 @@ class CheckCaptures extends Recheck, SymTransformer:
         report.warning(msg, tpt.srcPos)
       ccState.approxWarnings.clear()
 
-    /** Assert subcapturing `cs1 <: cs2` */
+    /** Assert subcapturing `cs1 <: cs2` (available for debugging, otherwise unused) */
     def assertSub(cs1: CaptureSet, cs2: CaptureSet)(using Context) =
       assert(cs1.subCaptures(cs2, frozen = false).isOK, i"$cs1 is not a subset of $cs2")
 
+    /** If `res` is not CompareResult.OK, report an error */
     def checkOK(res: CompareResult, prefix: => String, pos: SrcPos, provenance: => String = "")(using Context): Unit =
       if !res.isOK then
         def toAdd: String = CaptureSet.levelErrors.toAdd.mkString
@@ -299,25 +321,6 @@ class CheckCaptures extends Recheck, SymTransformer:
           else i"references $cs1$cs1description are not all",
           pos, provenance)
 
-    def showRef(ref: CaptureRef)(using Context): String =
-        ctx.printer.toTextCaptureRef(ref).show
-
-    /** The current environment */
-    private val rootEnv: Env = inContext(ictx):
-      Env(defn.RootClass, EnvKind.Regular, CaptureSet.empty, null)
-    private var curEnv = rootEnv
-
-    /** Currently checked closures and their expected types, used for error reporting */
-    private var openClosures: List[(Symbol, Type)] = Nil
-
-    private val myCapturedVars: util.EqHashMap[Symbol, CaptureSet] = EqHashMap()
-
-    /** A list of actions to perform at postCheck. The reason to defer these actions
-     *  is that it is sometimes better for type inference to not constrain too early
-     *  with a checkConformsExpr.
-     */
-    private var todoAtPostCheck = new mutable.ListBuffer[() => Unit]
-
     /** 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`.
      */
@@ -327,6 +330,8 @@ class CheckCaptures extends Recheck, SymTransformer:
         then CaptureSet.Var(sym.owner, level = sym.ccLevel)
         else CaptureSet.empty)
 
+// ---- Record Uses with MarkFree ----------------------------------------------------
+
     /** The next environment enclosing `env` that needs to be charged
      *  with free references.
      *  @param included Whether an environment is included in the range of
@@ -349,6 +354,9 @@ class CheckCaptures extends Recheck, SymTransformer:
       else
         i"\nof the enclosing ${owner.showLocated}"
 
+    /** Does the given environment belong to a method that is (a) nested in a term
+     *  and (b) not the method of an anonympus function?
+     */
     def isOfNestedMethod(env: Env | Null)(using Context) =
       env != null
       && env.owner.is(Method)
@@ -364,7 +372,7 @@ class CheckCaptures extends Recheck, SymTransformer:
     def markFree(sym: Symbol, ref: TermRef, pos: SrcPos)(using Context): Unit =
       if sym.exists && ref.isTracked then markFree(ref.captureSet, pos)
 
-    /** Make sure (projected) `cs` is a subset of the capture sets of all enclosing
+    /** Make sure the (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
      */
@@ -377,9 +385,12 @@ class CheckCaptures extends Recheck, SymTransformer:
         else
           !sym.isContainedIn(env.owner)
 
+      /** If captureRef `c` refers to a parameter that is not @use declared, report an error.
+       *  Exception under deferredReaches: If use comes from a nested closure, accept it.
+       */
       def checkUseDeclared(c: CaptureRef, env: Env, lastEnv: Env | Null) =
         if lastEnv != null && env.nestedClosure.exists && env.nestedClosure == lastEnv.owner then
-          () // access is from a nested closure, so it's OK
+          assert(ccConfig.deferredReaches) // access is from a nested closure under deferredReaches, so it's OK
         else c.pathRoot match
           case ref: NamedType if !ref.symbol.isUseParam =>
             val what = if ref.isType then "Capture set parameter" else "Local reach capability"
@@ -453,6 +464,9 @@ class CheckCaptures extends Recheck, SymTransformer:
           capt.println(i"Include call or box capture $included from $cs in ${env.owner} --> ${env.captured}")
           if !isOfNestedMethod(env) then
             recur(included, nextEnvToCharge(env, !_.owner.isStaticOwner), env)
+          // Don't propagate out of methods inside terms. The use set of these methods
+          // will be charged when that method is called.
+
       recur(cs, curEnv, null)
     end markFree
 
@@ -464,9 +478,9 @@ class CheckCaptures extends Recheck, SymTransformer:
 
     /** Under the sealed policy, disallow the root capability in type arguments.
      *  Type arguments come either from a TypeApply node or from an AppliedType
-     *  which represents a trait parent in a template. Also, if a corresponding
-     *  formal type parameter is declared or implied @use, charge the deep capture
-     *  set of the argument to the environent.
+     *  which represents a trait parent in a template.
+     *  Also, if a corresponding formal type parameter is declared or implied @use,
+     *  charge the deep capture set of the argument to the environent.
      *  @param  fn   the type application, of type TypeApply or TypeTree
      *  @param  sym  the constructor symbol (could be a method or a val or a class)
      *  @param  args the type arguments
@@ -499,22 +513,26 @@ class CheckCaptures extends Recheck, SymTransformer:
     override def recheckIdent(tree: Ident, pt: Type)(using Context): Type =
       val sym = tree.symbol
       if sym.is(Method) then
+        // If ident refers to a parameterless method, charge its cv to the environment
         includeCallCaptures(sym, sym.info, tree.srcPos)
       else if !sym.isStatic then
-        //debugShowEnvs()
+        // Otherwise charge its symbol, but add all selections implied by the e
+        // expected type `pt`.
+        // Example: If we have `x` and the expected type says we select that with `.a.b`,
+        // we charge `x.a.b` instead of `x`.
         def addSelects(ref: TermRef, pt: Type): TermRef = pt match
           case pt: PathSelectionProto if ref.isTracked =>
             // if `ref` is not tracked then the selection could not give anything new
             // class SerializationProxy in stdlib-cc/../LazyListIterable.scala has an example where this matters.
             addSelects(ref.select(pt.sym).asInstanceOf[TermRef], pt.pt)
           case _ => ref
-        val ref = sym.termRef
-        val pathRef = addSelects(ref, pt)
-        //if pathRef ne ref then
-        //  println(i"add selects $ref --> $pathRef")
-        markFree(sym, if false then ref else pathRef, tree.srcPos)
+        val pathRef = addSelects(sym.termRef, pt)
+        markFree(sym, pathRef, tree.srcPos)
       super.recheckIdent(tree, pt)
 
+    /** The expected type for the qualifier of a selection. If the selection
+     *  could be part of a capabaility path, we return a PathSelectionProto.
+     */
     override def selectionProto(tree: Select, pt: Type)(using Context): Type =
       val sym = tree.symbol
       if !sym.isOneOf(UnstableValueFlags) && !sym.isStatic then PathSelectionProto(sym, pt)
@@ -527,8 +545,8 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  E |- f.m: R^C
      *
      *  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.
+     *  outcome of a `mightSubcapture` test. It picks `{f}` if it might subcapture Cr
+     *  and picks Cr otherwise.
      */
     override def recheckSelection(tree: Select, qualType: Type, name: Name, pt: Type)(using Context) = {
       def disambiguate(denot: Denotation): Denotation = denot match
@@ -548,10 +566,14 @@ class CheckCaptures extends Recheck, SymTransformer:
       val selType = recheckSelection(tree, qualType, name, disambiguate)
       val selWiden = selType.widen
 
+      // Don't apply the rule
+      //   - on the LHS of assignments, or
+      //   - if the qualifier or selection type is boxed, or
+      //   - the selection is either a trackable capture ref or a pure type
       if pt == LhsProto
           || qualType.isBoxedCapturing
-          || selType.isTrackableRef
           || selWiden.isBoxedCapturing
+          || selType.isTrackableRef
           || selWiden.captureSet.isAlwaysEmpty
       then
         selType
@@ -561,7 +583,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         capt.println(i"pick one of $qualType, ${selType.widen}, $qualCs, $selCs ${selWiden.captureSet} in $tree")
 
         if qualCs.mightSubcapture(selCs)
-            && !selCs.mightSubcapture(qualCs)
+            //&& !selCs.mightSubcapture(qualCs)
             && !pt.stripCapturing.isInstanceOf[SingletonType]
         then
           selWiden.stripCapturing.capturing(qualCs)
@@ -570,7 +592,8 @@ class CheckCaptures extends Recheck, SymTransformer:
           selType
     }//.showing(i"recheck sel $tree, $qualType = $result")
 
-    /** Copy all @use annotations on method parameter symbols to the corresponding paramInfo types.
+    /** Hook for massaging a function before it is applied. Copies all @use annotations
+     *  on method parameter symbols to the corresponding paramInfo types.
      */
     override def prepareFunction(funtpe: MethodType, meth: Symbol)(using Context): MethodType =
       val paramInfosWithUses = funtpe.paramInfos.zipWithConserve(funtpe.paramNames): (formal, pname) =>
@@ -580,16 +603,18 @@ class CheckCaptures extends Recheck, SymTransformer:
           case _ => formal
       funtpe.derivedLambdaType(paramInfos = paramInfosWithUses)
 
-    override def recheckApply(tree: Apply, pt: Type)(using Context): Type =
-      val meth = tree.fun.symbol
+    /** If this is an application of a caps.unsafe method, handle it specially
+     *  otherwise return NoType.
+     */
+    private def recheckUnsafeApply(tree: Apply, pt: Type)(using Context): Type =
 
-      // Unsafe box/unbox handling, only for versions < 3.3
       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)
 
+      val meth = tree.fun.symbol
       if meth == defn.Caps_unsafeAssumePure then
         val arg :: Nil = tree.args: @unchecked
         val argType0 = recheck(arg, pt.capturing(CaptureSet.universal))
@@ -613,23 +638,33 @@ class CheckCaptures extends Recheck, SymTransformer:
           case tp @ CapturingType(parent, refs) =>
             tp.derivedCapturingType(forceBox(parent), refs)
         mapArgUsing(forceBox)
-      else
+      else NoType
+    end recheckUnsafeApply
+
+    /** Recheck applications. More work is done in `recheckApplication`,
+     *  `recheckArg` and `instantiate` below.
+     */
+    override def recheckApply(tree: Apply, pt: Type)(using Context): Type =
+      recheckUnsafeApply(tree, pt).orElse:
         val res = super.recheckApply(tree, pt)
-        includeCallCaptures(meth, res, tree.srcPos)
+        includeCallCaptures(tree.symbol, res, tree.srcPos)
         res
-    end recheckApply
 
-    protected override
-    def recheckArg(arg: Tree, formal: Type)(using Context): Type =
+    /** Recheck argument, and, if formal parameter carries a `@use`,
+     *  charge the deep capture set of the actual argument to the environment.
+     */
+    protected override def recheckArg(arg: Tree, formal: Type)(using Context): Type =
       val argType = recheck(arg, formal)
       formal match
         case AnnotatedType(formal1, ann) if ann.symbol == defn.UseAnnot =>
+          // The UseAnnot is added to `formal` by `prepareFunction`
           capt.println(i"charging deep capture set of $arg: ${argType} = ${argType.deepCaptureSet}")
           markFree(argType.deepCaptureSet, arg.srcPos)
         case _ =>
       argType
 
-    /** A specialized implementation of the apply rule.
+    /** Map existential captures in result to `cap` and implement the following
+     *  rele:
      *
      *  E |- q: Tq^Cq
      *  E |- q.f: Ta^Ca ->Cf Tr^Cr
@@ -646,7 +681,7 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  If the function `f` does have an `@use` parameter, then it could in addition
      *  unbox reach capabilities over its formal parameter. Therefore, the approximation
      *  would be `Cq \union dcs(Ca)` instead.
-     *  If the approximation is known to subcapture the declared result Cr, we pick it for C
+     *  If the approximation might subcapture the declared result Cr, we pick it for C
      *  otherwise we pick Cr.
      */
     protected override
@@ -675,12 +710,9 @@ class CheckCaptures extends Recheck, SymTransformer:
       case Nil => true
 
     /** Handle an application of method `sym` with type `mt` to arguments of types `argTypes`.
-     *  This means:
+     *  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.
+     *   - if `sym` is a constructor, refine its type with `refineInstanceType`
      *  If all argument types are mutually different trackable capture references, use a BiTypeMap,
      *  since that is more precise. Otherwise use a normal idempotent map, which might lose information
      *  in the case where the result type contains captureset variables that are further
@@ -694,49 +726,64 @@ class CheckCaptures extends Recheck, SymTransformer:
           SubstParamsBiMap(mt, argTypes)(mt.resType)
         else
           SubstParamsMap(mt, argTypes)(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) =
-          var refined: Type = core
-          var allCaptures: CaptureSet =
-            if core.derivesFromCapability then defn.universalCSImpliedByCapability else initCs
-          for (getterName, argType) <- mt.paramNames.lazyZip(argTypes) do
-            val getter = cls.info.member(getterName).suchThat(_.isRefiningParamAccessor).symbol
-            if !getter.is(Private) && getter.hasTrackedParts then
-              refined = RefinedType(refined, getterName, argType.unboxed)
-              allCaptures ++= argType.captureSet
-          (refined, allCaptures)
-
-        /** Augment result type of constructor with refinements and captures.
-         *  @param  core   The result type of the constructor
-         *  @param  initCs The initial capture set to add, not yet counting capture sets from arguments
-         */
-        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, capturedVars(cls) ++ capturedVars(sym))
-          .showing(i"constr type $mt with $argTypes%, % in $cls = $result", capt)
+      if sym.isConstructor then refineConstructorInstance(ownType, mt, argTypes, sym)
       else ownType
-    end instantiate
 
+    /** Refine the type returned from a constructor as follows:
+     *   - remember types of arguments corresponding to tracked parameters in refinements.
+     *   - add capture set of instantiated class and capture set of constructor to capture set of result type.
+     *  Note: This scheme does not distinguish whether a capture is made by the constructor
+     *  only or by a method in the class. Both captures go into the result type. We
+     *  could be more precise by distinguishing the two capture sets.
+     */
+    private def refineConstructorInstance(resType: Type, mt: MethodType, argTypes: List[Type], constr: Symbol)(using Context): Type =
+      val cls = constr.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 initial capture set and all capture sets of arguments
+       *  to tracked parameters.
+       */
+      def addParamArgRefinements(core: Type, initCs: CaptureSet): (Type, CaptureSet) =
+        var refined: Type = core
+        var allCaptures: CaptureSet =
+          if core.derivesFromCapability then defn.universalCSImpliedByCapability else initCs
+        for (getterName, argType) <- mt.paramNames.lazyZip(argTypes) do
+          val getter = cls.info.member(getterName).suchThat(_.isRefiningParamAccessor).symbol
+          if !getter.is(Private) && getter.hasTrackedParts then
+            refined = RefinedType(refined, getterName, argType.unboxed)
+            allCaptures ++= argType.captureSet
+        (refined, allCaptures)
+
+      /** Augment result type of constructor with refinements and captures.
+       *  @param  core   The result type of the constructor
+       *  @param  initCs The initial capture set to add, not yet counting capture sets from arguments
+       */
+      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(resType, capturedVars(cls) ++ capturedVars(constr))
+        .showing(i"constr type $mt with $argTypes%, % in $constr = $result", capt)
+    end refineConstructorInstance
+
+    /** Recheck type applications:
+     *   - Map existential captures in result to `cap`
+     *   - include captures of called methods in environment
+     *   - don't allow cap to appear covariantly in type arguments
+     *   - special handling of `contains[A, B]` calls
+     */
     override def recheckTypeApply(tree: TypeApply, pt: Type)(using Context): Type =
       val meth = tree.fun match
         case fun @ Select(qual, nme.apply) => qual.symbol.orElse(fun.symbol)
@@ -766,12 +813,19 @@ class CheckCaptures extends Recheck, SymTransformer:
     override def recheckBlock(tree: Block, pt: Type)(using Context): Type =
       inNestedLevel(super.recheckBlock(tree, pt))
 
+    /** Recheck Closure node: add the captured vars of the anonymoys function
+     *  to the result type. See also `recheckClosureBlock` which rechecks the
+     *  block containing the anonymous function and the Closure node.
+     */
     override def recheckClosure(tree: Closure, pt: Type, forceDependent: Boolean)(using Context): Type =
       val cs = capturedVars(tree.meth.symbol)
       capt.println(i"typing closure $tree with cvs $cs")
       super.recheckClosure(tree, pt, forceDependent).capturing(cs)
         .showing(i"rechecked closure $tree / $pt = $result", capt)
 
+    /** Recheck a lambda of the form
+     *      { def $anonfun(...) = ...; closure($anonfun, ...)}
+     */
     override def recheckClosureBlock(mdef: DefDef, expr: Closure, pt: Type)(using Context): Type =
       openClosures = (mdef.symbol, pt) :: openClosures
       try
@@ -779,12 +833,14 @@ class CheckCaptures extends Recheck, SymTransformer:
         // rechecking the body.
         val res = recheckClosure(expr, pt, forceDependent = true)
         if !(isEtaExpansion(mdef) && ccConfig.handleEtaExpansionsSpecially) then
-          // If closure is an eta expanded method reference it's better to not constrain
+          // Check whether the closure's results conforms to the expected type
+          // This constrains parameter types of the closure which can give better
+          // error messages.
+          // But if the closure is an eta expanded method reference it's better to not constrain
           // its internals early since that would give error messages in generated code
-          // which are less intelligible.
-          // Example is the line `a = x` in neg-custom-args/captures/vars.scala.
-          // For all other closures, early constraints are preferred since they
-          // give more localized error messages.
+          // which are less intelligible. An example is the line `a = x` in
+          // neg-custom-args/captures/vars.scala. That's why this code is conditioned.
+          // to apply only to closures that are not eta expansions.
           val res1 = Existential.toCapDeeply(res)
           val pt1 = Existential.toCapDeeply(pt)
             // We need to open existentials here in order not to get vars mixed up in them
@@ -797,42 +853,18 @@ class CheckCaptures extends Recheck, SymTransformer:
         openClosures = openClosures.tail
     end recheckClosureBlock
 
+    /** Elements of a SeqLiteral instantiate a Seq or Array parameter, so they
+     *  should be boxed.
+     */
     override def seqLiteralElemProto(tree: SeqLiteral, pt: Type, declared: Type)(using Context) =
       super.seqLiteralElemProto(tree, pt, declared).boxed
 
-    /** Maps mutable variables to the symbols that capture them (in the
-     *  CheckCaptures sense, i.e. symbol is referred to from a different method
-     *  than the one it is defined in).
-     */
-    private val capturedBy = util.HashMap[Symbol, Symbol]()
-
-    /** Maps anonymous functions appearing as function arguments to
-     *  the function that is called.
+    /** Recheck val and var definitions:
+     *   - disallow cap in the type of mutable vars.
+     *   - for externally visible definitions: check that their inferred type
+     *     does not refine what was known before capture checking.
+     *   - Interpolate contravariant capture set variables in result type.
      */
-    private val anonFunCallee = util.HashMap[Symbol, Symbol]()
-
-    /** Populates `capturedBy` and `anonFunCallee`. Called by `checkUnit`.
-     */
-    private def collectCapturedMutVars(using Context) = new TreeTraverser:
-      def traverse(tree: Tree)(using Context) = tree match
-        case id: Ident =>
-          val sym = id.symbol
-          if sym.is(Mutable, butNot = Method) && sym.owner.isTerm then
-            val enclMeth = ctx.owner.enclosingMethod
-            if sym.enclosingMethod != enclMeth then
-              capturedBy(sym) = enclMeth
-        case Apply(fn, args) =>
-          for case closureDef(mdef) <- args do
-            anonFunCallee(mdef.symbol) = fn.symbol
-          traverseChildren(tree)
-        case Inlined(_, bindings, expansion) =>
-          traverse(bindings)
-          traverse(expansion)
-        case mdef: DefDef =>
-          if !mdef.symbol.isInlineMethod then traverseChildren(tree)
-        case _ =>
-          traverseChildren(tree)
-
     override def recheckValDef(tree: ValDef, sym: Symbol)(using Context): Type =
       try
         if sym.is(Module) then sym.info // Modules are checked by checking the module class
@@ -861,10 +893,20 @@ class CheckCaptures extends Recheck, SymTransformer:
           // function is compiled since we do not propagate expected types into blocks.
           interpolateVarsIn(tree.tpt)
 
+    /** Recheck method definitions:
+     *   - check body in a nested environment that tracks uses, in  a nested level,
+     *     and in a nested context that knows abaout Contains parameters so that we
+     *     can assume they are true.
+     *   - for externally visible definitions: check that their inferred type
+     *     does not refine what was known before capture checking.
+     *   - Interpolate contravariant capture set variables in result type unless
+     *     def is anonymous.
+     */
     override def recheckDefDef(tree: DefDef, sym: Symbol)(using Context): Type =
       if Synthetics.isExcluded(sym) then sym.info
       else
-        // If rhs ends in a closure or anonymous class, the corresponding symbol
+        // Under the deferredReaches setting: If rhs ends in a closure or
+        // anonymous class, the corresponding symbol
         def nestedClosure(rhs: Tree)(using Context): Symbol =
           if !ccConfig.deferredReaches then NoSymbol
           else rhs match
@@ -889,7 +931,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           if ac.isEmpty then ctx
           else ctx.withProperty(CaptureSet.AssumedContains, Some(ac))
 
-        inNestedLevel: // TODO: needed here?
+        inNestedLevel: // TODO: nestedLevel needed here?
           try checkInferredResult(super.recheckDefDef(tree, sym)(using bodyCtx), tree)
           finally
             if !sym.isAnonymousFunction then
@@ -909,14 +951,14 @@ class CheckCaptures extends Recheck, SymTransformer:
       val sym = tree.symbol
 
       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.privateWithin == sym.effectiveOwner
-        || sym.name.is(DefaultGetterName) // default getters are exempted since otherwise it would be
+        sym.isLocalToCompilationUnit      // Symbols that can't be seen outside the compilation unit can always have inferred types
+        || sym.privateWithin == defn.EmptyPackageClass
+                                          // We make an exception for private symbols in a toplevel file in the empty package
+                                          // these could theoretically be accessed from other files in the empty package, but
+                                          // it would be too annoying to require explicit 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
-          sym.isLocalToCompilationUnit    // 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 addenda(expected: Type) = new Addenda:
         override def toAdd(using Context) =
@@ -933,23 +975,60 @@ class CheckCaptures extends Recheck, SymTransformer:
         case tpt: InferredTypeTree if !canUseInferred =>
           val expected = tpt.tpe.dropAllRetains
           todoAtPostCheck += (() => checkConformsExpr(tp, expected, tree.rhs, addenda(expected)))
+            // The check that inferred <: expected is done after recheck so that it
+            // does not interfere with normal rechecking by constraining capture set variables.
         case _ =>
       tp
     end checkInferredResult
 
-    /** Class-specific capture set relations:
+    /** The set of symbols that were rechecked via a completer */
+    private val completed = new mutable.HashSet[Symbol]
+
+    /** The normal rechecking if `sym` was already completed before */
+    override def skipRecheck(sym: Symbol)(using Context): Boolean =
+      completed.contains(sym)
+
+    /** Check a ValDef or DefDef as an action performed in a completer. Since
+     *  these checks can appear out of order, we need to first create the correct
+     *  environment for checking the definition.
+     */
+    def completeDef(tree: ValOrDefDef, sym: Symbol)(using Context): Type =
+      val saved = curEnv
+      try
+        // Setup environment to reflect the new owner.
+        val envForOwner: Map[Symbol, Env] = curEnv.outersIterator
+          .takeWhile(e => !capturedVars(e.owner).isAlwaysEmpty) // no refs can leak beyond this point
+          .map(e => (e.owner, e))
+          .toMap
+        def restoreEnvFor(sym: Symbol): Env =
+          val localSet = capturedVars(sym)
+          if localSet.isAlwaysEmpty then rootEnv
+          else envForOwner.get(sym) match
+            case Some(e) => e
+            case None => Env(sym, EnvKind.Regular, localSet, restoreEnvFor(sym.owner))
+        curEnv = restoreEnvFor(sym.owner)
+        capt.println(i"Complete $sym in ${curEnv.outersIterator.toList.map(_.owner)}")
+        try recheckDef(tree, sym)
+        finally completed += sym
+      finally
+        curEnv = saved
+
+    /** Recheck classDef by enforcing the following 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.
+     *      unless the parameter is marked @constructorOnly or @untrackedCaptures.
      *   4. If the class extends a pure base class, the capture set of the self type must be empty.
+     *  Also, check that trait parents represented as applied types don't have cap in their
+     *  type arguments. Other generic parents are represented as TypeApplys, where the same check
+     *  is already done in the TypeApply.
      */
     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,
           i"\nof the references allowed to be captured by $cls")
+      val saved = curEnv
       if !localSet.isAlwaysEmpty then
         curEnv = Env(cls, EnvKind.Regular, localSet, curEnv)
       try
@@ -960,15 +1039,15 @@ class CheckCaptures extends Recheck, SymTransformer:
             && !param.hasAnnotation(defn.UntrackedCapturesAnnot) then
             checkSubset(param.termRef.captureSet, thisSet, param.srcPos) // (3)
         for pureBase <- cls.pureBaseClass do // (4)
-          def selfType = impl.body
+          def selfTypeTree = impl.body
             .collect:
               case TypeDef(tpnme.SELF, rhs) => rhs
             .headOption
-            .getOrElse(tree)
-            .orElse(tree)
+            .getOrElse(tree)  // Use class tree if self type tree is missing ...
+            .orElse(tree)     // ... or empty.
           checkSubset(thisSet,
             CaptureSet.empty.withDescription(i"of pure base class $pureBase"),
-            selfType.srcPos, cs1description = " captured by this self type")
+            selfTypeTree.srcPos, cs1description = " captured by this self type")
         for case tpt: TypeTree <- impl.parents do
           tpt.tpe match
             case AppliedType(fn, args) =>
@@ -993,6 +1072,9 @@ class CheckCaptures extends Recheck, SymTransformer:
         case _ =>
       super.recheckTyped(tree)
 
+    /** Under the sealed policy and with saferExceptions, disallow cap in the
+     *  result type of a try
+     */
     override def recheckTry(tree: Try, pt: Type)(using Context): Type =
       val tp = super.recheckTry(tree, pt)
       if ccConfig.useSealed && Feature.enabled(Feature.saferExceptions) then
@@ -1018,10 +1100,12 @@ class CheckCaptures extends Recheck, SymTransformer:
       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.
+    /** The main recheck method does some box adapation for all nodes:
+     *   - If expected type `pt` is boxed and the tree is a lambda or a reference,
+     *     don't propagate free variables.
+     *   - If the expected type is not boxed but the result type is boxed,
+     *     simulate an unboxing by adding all references in the boxed capture set
+     *     of the result type to the current environment.
      */
     override def recheck(tree: Tree, pt: Type = WildcardType)(using Context): Type =
       val saved = curEnv
@@ -1036,14 +1120,12 @@ class CheckCaptures extends Recheck, SymTransformer:
           else
             trace.force(i"rechecking $tree with pt = $pt", recheckr, show = true):
               super.recheck(tree, pt)
-        catch case ex: NoCommonRoot =>
-          report.error(ex.getMessage.nn)
-          tree.tpe
         finally curEnv = saved
       if tree.isTerm && !pt.isBoxedCapturing && pt != LhsProto then
         markFree(res.boxedCaptureSet, tree.srcPos)
       res
 
+    /** Under the old unsealed policy: check that cap is ot unboxed */
     override def recheckFinish(tpe: Type, tree: Tree, pt: Type)(using Context): Type =
       checkNotUniversalInUnboxedResult(tpe, tree)
       super.recheckFinish(tpe, tree, pt)
@@ -1073,6 +1155,10 @@ class CheckCaptures extends Recheck, SymTransformer:
               |
               |Note that ${msg.toString}"""
 
+    /** Addendas for error messages that show where we have under-approximated by
+     *  mapping a a capture ref in contravariant position to the empty set because
+     *  the original result type of the map was not itself a capture ref.
+     */
     private def addApproxAddenda(using Context) =
       new TypeAccumulator[Addenda]:
         def apply(add: Addenda, t: Type) = t match
@@ -1253,6 +1339,7 @@ class CheckCaptures extends Recheck, SymTransformer:
 
         def adaptStr = i"adapting $actual ${if covariant then "~~>" else "<~~"} $expected"
 
+        // Get existentials and wildcards out of the way
         actual match
           case actual @ Existential(_, actualUnpacked) =>
             return Existential.derivedExistentialType(actual):
@@ -1286,11 +1373,10 @@ class CheckCaptures extends Recheck, SymTransformer:
           else
             if !leaked.subCaptures(cs, frozen = false).isOK then
               report.error(
-                em"""$expected cannot be box-converted to $actual
+                em"""$expected cannot be box-converted to ${actual.capturing(leaked)}
                     |since the additional capture set $leaked resulted from box conversion is not allowed in $actual""", pos)
             cs
 
-        // Compute the adapted type
         def adaptedType(resultBoxed: Boolean) =
           if (adaptedShape eq actualShape) && leaked.isAlwaysEmpty && actualIsBoxed == resultBoxed
           then actual
@@ -1299,35 +1385,43 @@ class CheckCaptures extends Recheck, SymTransformer:
             .forceBoxStatus(resultBoxed)
 
         if needsAdaptation then
-          val criticalSet =          // the set which is not allowed to have `cap`
-            if covariant then captures    // can't box with `cap`
-            else expected.captureSet // can't unbox with `cap`
+          val criticalSet =          // the set with which we box or unbox
+            if covariant then captures   // covariant: we box with captures of actual type plus captures leaked by inner adapation
+            else expected.captureSet     // contravarant: we unbox with captures of epected type
           def msg = em"""$actual cannot be box-converted to $expected
                         |since at least one of their capture sets contains the root capability `cap`"""
           def allowUniversalInBoxed =
             ccConfig.useSealed
             || expected.hasAnnotation(defn.UncheckedCapturesAnnot)
             || actual.widen.hasAnnotation(defn.UncheckedCapturesAnnot)
-          if criticalSet.isUnboxable && expected.isValueType && !allowUniversalInBoxed then
-            // We can't box/unbox the universal capability. Leave `actual` as it is
-            // so we get an error in checkConforms. Add the error message generated
-            // from boxing as an addendum. This tends to give better error
-            // messages than disallowing the root capability in `criticalSet`.
-            if boxErrors != null then boxErrors += msg
-            if ctx.settings.YccDebug.value then
-              println(i"cannot box/unbox $actual vs $expected")
-            actual
-          else
-            if !allowUniversalInBoxed then
-              // Disallow future addition of `cap` to `criticalSet`.
-              criticalSet.disallowRootCapability: () =>
-                report.error(msg, pos)
-            if !insertBox then  // unboxing
-              //debugShowEnvs()
-              markFree(criticalSet, pos)
-            adaptedType(!actualIsBoxed)
-        else
-          adaptedType(actualIsBoxed)
+          if !allowUniversalInBoxed then
+            if criticalSet.isUnboxable && expected.isValueType then
+              // We can't box/unbox the universal capability. Leave `actual` as it is
+              // so we get an error in checkConforms. Add the error message generated
+              // from boxing as an addendum. This tends to give better error
+              // messages than disallowing the root capability in `criticalSet`.
+              if boxErrors != null then boxErrors += msg
+              if ctx.settings.YccDebug.value then
+                println(i"cannot box/unbox $actual vs $expected")
+              return actual
+            // Disallow future addition of `cap` to `criticalSet`.
+            criticalSet.disallowRootCapability: () =>
+              report.error(msg, pos)
+
+          if !insertBox then  // we are unboxing
+            //debugShowEnvs()
+            markFree(criticalSet, pos)
+        end if
+
+        // Compute the adapted type.
+        // The result is boxed if actual is boxed and we don't need to adapt,
+        // or if actual is unboxed and we do need to adapt.
+        val resultIsBoxed = actualIsBoxed != needsAdaptation
+        if (adaptedShape eq actualShape) && leaked.isAlwaysEmpty && actualIsBoxed == resultIsBoxed
+          then actual
+          else adaptedShape
+            .capturing(if alwaysConst then CaptureSet(captures.elems) else captures)
+            .forceBoxStatus(resultIsBoxed)
         }
       end recur
 
@@ -1352,9 +1446,10 @@ class CheckCaptures extends Recheck, SymTransformer:
           case _ => widened
       case _ => widened
 
-    /** Adapt `actual` type to `expected` type by inserting boxing and unboxing conversions
-     *
-     *  @param alwaysConst  always make capture set variables constant after adaptation
+    /** Adapt `actual` type to `expected` type. This involves:
+     *   - narrow toplevel captures of `x`'s underlying type to `{x}` according to CC's VAR rule
+     *   - narrow nested captures of `x`'s underlying type to `{x*}`
+     *   - do box adaptation
      */
     def adapt(actual: Type, expected: Type, pos: SrcPos, boxErrors: BoxErrors)(using Context): Type =
       if expected == LhsProto || expected.isSingleton && actual.isSingleton then
@@ -1368,6 +1463,8 @@ class CheckCaptures extends Recheck, SymTransformer:
         else adapted.showing(i"adapt boxed $actual vs $expected = $adapted", capt)
     end adapt
 
+// ---- Unit-level rechecking -------------------------------------------
+
     /** 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
@@ -1398,6 +1495,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             finally curEnv = saved
           actual1 frozen_<:< expected1
 
+        /** Omit the check if one of {overriding,overridden} was nnot capture checked */
         override def needsCheck(overriding: Symbol, overridden: Symbol)(using Context): Boolean =
           !setup.isPreCC(overriding) && !setup.isPreCC(overridden)
 
@@ -1425,36 +1523,43 @@ class CheckCaptures extends Recheck, SymTransformer:
             checkAllOverrides(ctx.owner.asClass, OverridingPairsCheckerCC(_, _, t))
           case _ =>
         traverseChildren(t)
+    end checkOverrides
 
-    private val completed = new mutable.HashSet[Symbol]
+    /** Used for error reporting:
+     *  Maps mutable variables to the symbols that capture them (in the
+     *  CheckCaptures sense, i.e. symbol is referred to from a different method
+     *  than the one it is defined in).
+     */
+    private val capturedBy = util.HashMap[Symbol, Symbol]()
 
-    override def skipRecheck(sym: Symbol)(using Context): Boolean =
-      completed.contains(sym)
+    /** Used for error reporting:
+     *  Maps anonymous functions appearing as function arguments to
+     *  the function that is called.
+     */
+    private val anonFunCallee = util.HashMap[Symbol, Symbol]()
 
-    /** Check a ValDef or DefDef as an action performed in a completer. Since
-     *  these checks can appear out of order, we need to firsty create the correct
-     *  environment for checking the definition.
+    /** Used for error reporting:
+     *  Populates `capturedBy` and `anonFunCallee`. Called by `checkUnit`.
      */
-    def completeDef(tree: ValOrDefDef, sym: Symbol)(using Context): Type =
-      val saved = curEnv
-      try
-        // Setup environment to reflect the new owner.
-        val envForOwner: Map[Symbol, Env] = curEnv.outersIterator
-          .takeWhile(e => !capturedVars(e.owner).isAlwaysEmpty) // no refs can leak beyind this point
-          .map(e => (e.owner, e))
-          .toMap
-        def restoreEnvFor(sym: Symbol): Env =
-          val localSet = capturedVars(sym)
-          if localSet.isAlwaysEmpty then rootEnv
-          else envForOwner.get(sym) match
-            case Some(e) => e
-            case None => Env(sym, EnvKind.Regular, localSet, restoreEnvFor(sym.owner))
-        curEnv = restoreEnvFor(sym.owner)
-        capt.println(i"Complete $sym in ${curEnv.outersIterator.toList.map(_.owner)}")
-        try recheckDef(tree, sym)
-        finally completed += sym
-      finally
-        curEnv = saved
+    private def collectCapturedMutVars(using Context) = new TreeTraverser:
+      def traverse(tree: Tree)(using Context) = tree match
+        case id: Ident =>
+          val sym = id.symbol
+          if sym.is(Mutable, butNot = Method) && sym.owner.isTerm then
+            val enclMeth = ctx.owner.enclosingMethod
+            if sym.enclosingMethod != enclMeth then
+              capturedBy(sym) = enclMeth
+        case Apply(fn, args) =>
+          for case closureDef(mdef) <- args do
+            anonFunCallee(mdef.symbol) = fn.symbol
+          traverseChildren(tree)
+        case Inlined(_, bindings, expansion) =>
+          traverse(bindings)
+          traverse(expansion)
+        case mdef: DefDef =>
+          if !mdef.symbol.isInlineMethod then traverseChildren(tree)
+        case _ =>
+          traverseChildren(tree)
 
     private val setup: SetupAPI = thisPhase.prev.asInstanceOf[Setup]
 
@@ -1475,6 +1580,9 @@ class CheckCaptures extends Recheck, SymTransformer:
         postCheckWF(unit.tpdTree)
         if ctx.settings.YccDebug.value then
           show(unit.tpdTree) // this does not print tree, but makes its variables visible for dependency printing
+    end checkUnit
+
+// ----- Checks to do after the rechecking traversal --------------------------
 
     /** 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
@@ -1602,6 +1710,10 @@ class CheckCaptures extends Recheck, SymTransformer:
         checker.traverse(tree.knownType)
     end healTypeParam
 
+    /** Under the unsealed policy: Arrays are like vars, check that their element types
+     *  do not contains `cap` (in fact it would work also to check on array creation
+     *  like we do under sealed).
+     */
     def checkArraysAreSealedIn(tp: Type, pos: SrcPos)(using Context): Unit =
       val check = new TypeTraverser:
         def traverse(t: Type): Unit =
@@ -1643,7 +1755,7 @@ class CheckCaptures extends Recheck, SymTransformer:
                 checkBounds(normArgs, tl)
                 args.lazyZip(tl.paramNames).foreach(healTypeParam(_, _, fun.symbol))
               case _ =>
-          case tree: TypeTree =>
+          case tree: TypeTree if !ccConfig.useSealed =>
             checkArraysAreSealedIn(tree.tpe, tree.srcPos)
           case _ =>
         end check
diff --git a/tests/pos-custom-args/captures/vars1.scala b/tests/pos-custom-args/captures/vars1.scala
index 451b8988364f..c8d887e38463 100644
--- a/tests/pos-custom-args/captures/vars1.scala
+++ b/tests/pos-custom-args/captures/vars1.scala
@@ -8,7 +8,7 @@ object Test:
   var defaultIncompleteHandler: ErrorHandler = ???
   @uncheckedCaptures
   var incompleteHandler: ErrorHandler = defaultIncompleteHandler
-  private val x = incompleteHandler.unsafeUnbox
+  private val x = incompleteHandler
   val _ : ErrorHandler = x
   val _ = x(1, "a")
 

From b9d485a125844c1f9a567f674e5d441587d15987 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Fri, 8 Nov 2024 19:21:16 +0100
Subject: [PATCH 222/306] Drop legacy caps.unsafe operations

Retain only caps.unsafe.unsafeAssumePure
---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  |  2 -
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 39 +++++++------------
 .../dotty/tools/dotc/core/Definitions.scala   |  3 --
 library/src/scala/caps.scala                  | 16 --------
 4 files changed, 13 insertions(+), 47 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index eef1b5caacd1..6eb56fd69ab2 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -584,8 +584,6 @@ extension (sym: Symbol)
       case _ => false
     containsEnclTypeParam(sym.info.finalResultType)
     && !sym.allowsRootCapture
-    && sym != defn.Caps_unsafeBox
-    && sym != defn.Caps_unsafeUnbox
     && !defn.isPolymorphicAfterErasure(sym)
     && !defn.isTypeTestOrCast(sym)
 
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 41a35cb52d39..8b811bf61809 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -607,13 +607,6 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  otherwise return NoType.
      */
     private def recheckUnsafeApply(tree: Apply, pt: Type)(using Context): Type =
-
-      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)
-
       val meth = tree.fun.symbol
       if meth == defn.Caps_unsafeAssumePure then
         val arg :: Nil = tree.args: @unchecked
@@ -623,31 +616,25 @@ class CheckCaptures extends Recheck, SymTransformer:
           else argType0.widen.stripCapturing
         capt.println(i"rechecking $arg with $pt: $argType")
         super.recheckFinish(argType, tree, pt)
-      else 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
-        def forceBox(tp: Type): Type = tp.strippedDealias match
-          case defn.FunctionOf(paramtpe :: Nil, restpe, isContextual) =>
-            defn.FunctionOf(paramtpe.forceBoxStatus(true) :: Nil, restpe, isContextual)
-          case tp @ RefinedType(parent, rname, rinfo: MethodType) =>
-            tp.derivedRefinedType(parent, rname,
-              rinfo.derivedLambdaType(
-                paramInfos = rinfo.paramInfos.map(_.forceBoxStatus(true))))
-          case tp @ CapturingType(parent, refs) =>
-            tp.derivedCapturingType(forceBox(parent), refs)
-        mapArgUsing(forceBox)
       else NoType
     end recheckUnsafeApply
 
-    /** Recheck applications. More work is done in `recheckApplication`,
-     *  `recheckArg` and `instantiate` below.
+    /** Recheck applications, with special handling of unsafeAssumePure.
+     *  More work is done in `recheckApplication`, `recheckArg` and `instantiate` below.
      */
     override def recheckApply(tree: Apply, pt: Type)(using Context): Type =
-      recheckUnsafeApply(tree, pt).orElse:
+      val meth = tree.fun.symbol
+      if meth == defn.Caps_unsafeAssumePure then
+        val arg :: Nil = tree.args: @unchecked
+        val argType0 = recheck(arg, pt.capturing(CaptureSet.universal))
+        val argType =
+          if argType0.captureSet.isAlwaysEmpty then argType0
+          else argType0.widen.stripCapturing
+        capt.println(i"rechecking $arg with $pt: $argType")
+        super.recheckFinish(argType, tree, pt)
+      else
         val res = super.recheckApply(tree, pt)
-        includeCallCaptures(tree.symbol, res, tree.srcPos)
+        includeCallCaptures(meth, res, tree.srcPos)
         res
 
     /** Recheck argument, and, if formal parameter carries a `@use`,
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 1e36cb6f22db..2890bdf306be 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -999,9 +999,6 @@ class Definitions {
     @tu lazy val Caps_Exists: ClassSymbol = requiredClass("scala.caps.Exists")
     @tu lazy val CapsUnsafeModule: Symbol = requiredModule("scala.caps.unsafe")
     @tu lazy val Caps_unsafeAssumePure: Symbol = CapsUnsafeModule.requiredMethod("unsafeAssumePure")
-    @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")
     @tu lazy val Caps_ContainsTrait: TypeSymbol = CapsModule.requiredType("Contains")
     @tu lazy val Caps_containsImpl: TermSymbol = CapsModule.requiredMethod("containsImpl")
 
diff --git a/library/src/scala/caps.scala b/library/src/scala/caps.scala
index 6c7610e410c0..53c4ae7dc0dd 100644
--- a/library/src/scala/caps.scala
+++ b/library/src/scala/caps.scala
@@ -66,20 +66,4 @@ import annotation.{experimental, compileTimeOnly, retainsCap}
        */
       def unsafeAssumePure: T = x
 
-      /** If argument is of type `cs T`, converts to type `box cs T`. This
-      *  avoids the error that would be raised when boxing `cap`.
-      */
-      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 `cap`.
-       */
-      def unsafeUnbox: T = x
-
-    extension [T, U](f: T => U)
-      /** If argument is of type `box cs T`, converts to type `cs T`. This
-       *  avoids the error that would be raised when unboxing `cap`.
-       */
-      def unsafeBoxFunArg: T => U = f
-
   end unsafe

From 1e79a2dea28d322af643bfdc33cf76b1b184ae50 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Fri, 8 Nov 2024 19:24:30 +0100
Subject: [PATCH 223/306] Don't show redudundant existental wrappers

Don't show an `(ex$n: Exists) ->` if the bound variable
does not appear in the result. The full type will be shown under -Ycc-debug.

Also, avoid spurious ineffective mappings in widenReach.
---
 compiler/src/dotty/tools/dotc/cc/CaptureOps.scala        | 9 +++++++--
 .../src/dotty/tools/dotc/printing/RefinedPrinter.scala   | 5 ++++-
 scala2-library-cc/src/scala/collection/SeqView.scala     | 1 -
 tests/neg-custom-args/captures/i21620.check              | 4 ++--
 tests/neg-custom-args/captures/lazylist.check            | 6 +++---
 tests/neg-custom-args/captures/reaches2.check            | 4 ++--
 tests/neg-custom-args/captures/real-try.check            | 2 +-
 tests/neg-custom-args/captures/use-capset.check          | 4 ++--
 tests/neg-custom-args/captures/uses.check                | 4 ++--
 9 files changed, 23 insertions(+), 16 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index 6eb56fd69ab2..b19e46de5cf1 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -476,10 +476,12 @@ extension (tp: Type)
    */
   def withReachCaptures(ref: Type)(using Context): Type =
     object narrowCaps extends TypeMap:
+      var change = false
       def apply(t: Type) =
         if variance <= 0 then t
         else t.dealiasKeepAnnots match
           case t @ CapturingType(p, cs) if cs.isUniversal =>
+            change = true
             t.derivedCapturingType(apply(p), ref.reach.singletonCaptureSet)
           case t @ AnnotatedType(parent, ann) =>
             // Don't map annotations, which includes capture sets
@@ -498,8 +500,11 @@ extension (tp: Type)
     ref match
       case ref: CaptureRef if ref.isTrackableRef =>
         val tp1 = narrowCaps(tp)
-        if tp1 ne tp then capt.println(i"narrow $tp of $ref to $tp1")
-        tp1
+        if narrowCaps.change then
+          capt.println(i"narrow $tp of $ref to $tp1")
+          tp1
+        else
+          tp
       case _ =>
         tp
 
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 3caba59a091f..95a0007c1dfe 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -30,7 +30,7 @@ import config.SourceVersion.*
 
 import dotty.tools.dotc.util.SourcePosition
 import dotty.tools.dotc.ast.untpd.{MemberDef, Modifiers, PackageDef, RefTree, Template, TypeDef, ValOrDefDef}
-import cc.{CaptureSet, CapturingType, toCaptureSet, IllegalCaptureRef, isRetains, ReachCapability, MaybeCapability}
+import cc.{CaptureSet, CapturingType, toCaptureSet, IllegalCaptureRef, isRetains, ReachCapability, MaybeCapability, Existential}
 import dotty.tools.dotc.parsing.JavaParsers
 
 class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
@@ -285,6 +285,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       if !printDebug && appliedText(tp.asInstanceOf[HKLambda].resType).isEmpty =>
         // don't eta contract if the application would be printed specially
         toText(tycon)
+      case Existential(boundVar, unpacked)
+      if !printDebug && !ctx.settings.YccDebug.value && !unpacked.existsPart(_ == boundVar) =>
+        toText(unpacked)
       case tp: RefinedType if defn.isFunctionType(tp) && !printDebug =>
         toTextMethodAsFunction(tp.refinedInfo,
           isPure = Feature.pureFunsEnabled && !tp.typeSymbol.name.isImpureFunction,
diff --git a/scala2-library-cc/src/scala/collection/SeqView.scala b/scala2-library-cc/src/scala/collection/SeqView.scala
index 292dc61ddaa8..30207fca46ff 100644
--- a/scala2-library-cc/src/scala/collection/SeqView.scala
+++ b/scala2-library-cc/src/scala/collection/SeqView.scala
@@ -16,7 +16,6 @@ package collection
 import scala.annotation.nowarn
 import language.experimental.captureChecking
 import caps.unsafe.unsafeAssumePure
-import scala.annotation.unchecked.uncheckedCaptures
 
 /** !!! Scala 2 difference: Need intermediate trait SeqViewOps to collect the
  *  necessary functionality over which SeqViews are defined, and at the same
diff --git a/tests/neg-custom-args/captures/i21620.check b/tests/neg-custom-args/captures/i21620.check
index ddfcdafab36f..d5be3bab9e73 100644
--- a/tests/neg-custom-args/captures/i21620.check
+++ b/tests/neg-custom-args/captures/i21620.check
@@ -13,14 +13,14 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i21620.scala:9:31 ----------------------------------------
 9 |  val _: () -> () ->{x} Unit = f // error
   |                               ^
-  |                               Found:    () ->{f} () ->{x} Unit
+  |                               Found:    (f : () ->{x} () ->{x} Unit)
   |                               Required: () -> () ->{x} Unit
   |
   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i21620.scala:20:33 ---------------------------------------
 20 |  val _: () ->{} () ->{x} Unit = f   // error, but could be OK
    |                                 ^
-   |                                 Found:    () ->{f} () ->{x} Unit
+   |                                 Found:    (f : () ->{x} () ->{x} Unit)
    |                                 Required: () -> () ->{x} Unit
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/lazylist.check b/tests/neg-custom-args/captures/lazylist.check
index f0fbd1a025b5..bc95a445f3f4 100644
--- a/tests/neg-custom-args/captures/lazylist.check
+++ b/tests/neg-custom-args/captures/lazylist.check
@@ -8,8 +8,8 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylist.scala:35:29 -------------------------------------
 35 |  val ref1c: LazyList[Int] = ref1 // error
    |                             ^^^^
-   |                         Found:    lazylists.LazyCons[Int]{val xs: () ->{cap1} lazylists.LazyList[Int]^?}^{ref1}
-   |                         Required: lazylists.LazyList[Int]
+   |                Found:    (ref1 : lazylists.LazyCons[Int]{val xs: () ->{cap1} lazylists.LazyList[Int]^?}^{cap1})
+   |                Required: lazylists.LazyList[Int]
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylist.scala:37:36 -------------------------------------
@@ -29,7 +29,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylist.scala:41:42 -------------------------------------
 41 |  val ref4c: LazyList[Int]^{cap1, ref3} = ref4 // error
    |                                          ^^^^
-   |                                          Found:    (ref4 : lazylists.LazyList[Int]^{cap3, ref2, ref1})
+   |                                          Found:    (ref4 : lazylists.LazyList[Int]^{cap3, cap2, ref1, cap1})
    |                                          Required: lazylists.LazyList[Int]^{cap1, ref3}
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/reaches2.check b/tests/neg-custom-args/captures/reaches2.check
index 03860ee4a01b..1e921ee92072 100644
--- a/tests/neg-custom-args/captures/reaches2.check
+++ b/tests/neg-custom-args/captures/reaches2.check
@@ -2,9 +2,9 @@
 8 |  ps.map((x, y) => compose1(x, y)) // error // error
   |          ^
   |reference ps* is not included in the allowed capture set {}
-  |of an enclosing function literal with expected type ((box A ->{ps*} A, box A ->{ps*} A)) -> box (x$0: A^?) ->? (ex$15: caps.Exists) -> A^?
+  |of an enclosing function literal with expected type ((box A ->{ps*} A, box A ->{ps*} A)) -> box (x$0: A^?) ->? A^?
 -- Error: tests/neg-custom-args/captures/reaches2.scala:8:13 -----------------------------------------------------------
 8 |  ps.map((x, y) => compose1(x, y)) // error // error
   |             ^
   |reference ps* is not included in the allowed capture set {}
-  |of an enclosing function literal with expected type ((box A ->{ps*} A, box A ->{ps*} A)) -> box (x$0: A^?) ->? (ex$15: caps.Exists) -> A^?
+  |of an enclosing function literal with expected type ((box A ->{ps*} A, box A ->{ps*} A)) -> box (x$0: A^?) ->? A^?
diff --git a/tests/neg-custom-args/captures/real-try.check b/tests/neg-custom-args/captures/real-try.check
index a6f514addc95..12ea7262007a 100644
--- a/tests/neg-custom-args/captures/real-try.check
+++ b/tests/neg-custom-args/captures/real-try.check
@@ -27,7 +27,7 @@
 -- Error: tests/neg-custom-args/captures/real-try.scala:26:10 ----------------------------------------------------------
 26 |  val y = try  // error
    |          ^
-   |          The result of `try` cannot have type () => (ex$8: caps.Exists) -> Cell[Unit]^? since
+   |          The result of `try` cannot have type () => Cell[Unit]^? since
    |          that type captures the root capability `cap`.
    |          This is often caused by a locally generated exception capability leaking as part of its result.
 27 |    () => Cell(foo(1))
diff --git a/tests/neg-custom-args/captures/use-capset.check b/tests/neg-custom-args/captures/use-capset.check
index d94ff90cddb8..4002e6569c94 100644
--- a/tests/neg-custom-args/captures/use-capset.check
+++ b/tests/neg-custom-args/captures/use-capset.check
@@ -13,7 +13,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/use-capset.scala:15:50 -----------------------------------
 15 |  val _: () -> List[Object^{io}] -> Object^{io} = h2 // error, should be ->{io}
    |                                                  ^^
-   |                     Found:    () ->? (x$0: List[box Object^{io}]^{}) ->{io} (ex$13: caps.Exists) -> Object^{io}
-   |                     Required: () -> List[box Object^{io}] -> Object^{io}
+   |                                      Found:    (h2 : () ->? (x$0: List[box Object^{io}]^{}) ->{io} Object^{io})
+   |                                      Required: () -> List[box Object^{io}] -> Object^{io}
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/uses.check b/tests/neg-custom-args/captures/uses.check
index de583d75db06..d201d79133cf 100644
--- a/tests/neg-custom-args/captures/uses.check
+++ b/tests/neg-custom-args/captures/uses.check
@@ -15,14 +15,14 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/uses.scala:18:34 -----------------------------------------
 18 |  val _: () ->{x} () ->{y} Unit = g // error, should be ok
    |                                  ^
-   |                                  Found:    () ->{x, y} (ex$7: caps.Exists) -> () ->{y} Unit
+   |                                  Found:    () ->{x, y} () ->{y} Unit
    |                                  Required: () ->{x} () ->{y} Unit
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/uses.scala:19:28 -----------------------------------------
 19 |  val _: () -> () -> Unit = g // error
    |                            ^
-   |                            Found:    () ->{x, y} (ex$7: caps.Exists) -> () ->{y} Unit
+   |                            Found:    () ->{x, y} () ->{y} Unit
    |                            Required: () -> () -> Unit
    |
    | longer explanation available when compiling with `-explain`

From ff73a2f944c29449d6aa83b0a091e55fd4dd1443 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Fri, 8 Nov 2024 19:38:06 +0100
Subject: [PATCH 224/306] Use unsafeAssumePure instead of asInstanceOf in
 stdlib-cc

---
 scala2-library-cc/src/scala/collection/Iterator.scala | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/scala2-library-cc/src/scala/collection/Iterator.scala b/scala2-library-cc/src/scala/collection/Iterator.scala
index 7d5af9f021dc..91a22caa288c 100644
--- a/scala2-library-cc/src/scala/collection/Iterator.scala
+++ b/scala2-library-cc/src/scala/collection/Iterator.scala
@@ -17,7 +17,7 @@ import scala.annotation.tailrec
 import scala.annotation.unchecked.uncheckedVariance
 import scala.runtime.Statics
 import language.experimental.captureChecking
-
+import caps.unsafe.unsafeAssumePure
 
 /** Iterators are data structures that allow to iterate over a sequence
   * of elements. They have a `hasNext` method for checking
@@ -1008,7 +1008,7 @@ object Iterator extends IterableFactory[Iterator] {
   def newBuilder[A]: Builder[A, Iterator[A]] =
     new ImmutableBuilder[A, Iterator[A]](empty[A]) {
       override def addOne(elem: A): this.type = { elems = elems ++ single(elem); this }
-    }.asInstanceOf // !!! CC unsafe op
+    }.unsafeAssumePure
 
   /** Creates iterator that produces the results of some element computation a number of times.
     *
@@ -1160,7 +1160,7 @@ object Iterator extends IterableFactory[Iterator] {
         @tailrec def merge(): Unit =
           if (current.isInstanceOf[ConcatIterator[_]]) {
             val c: ConcatIterator[A] = current.asInstanceOf
-            current = c.current.asInstanceOf // !!! CC unsafe op
+            current = c.current.unsafeAssumePure // !!! CC unsafe op
             currentHasNextChecked = c.currentHasNextChecked
             if (c.tail != null) {
               if (last == null) last = c.last

From a98903cb371f6f79f761a36c154148834cc9a946 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 11 Nov 2024 13:20:44 +0100
Subject: [PATCH 225/306] Treat by-name closures specially in recheck

A by-name Closure node, which is produced by phase ElimByName gets a target type to indicate
it's a contextual zero parameter closure. But for the purposes of rechecking and capture checking,
it needs to be treated like a function. In particular the type of the closure needs to be derived
from the result type of the anonymous function.

Fixes #21920
---
 .../tools/dotc/transform/ElimByName.scala     |  3 ++
 .../dotty/tools/dotc/transform/Recheck.scala  |  4 +++
 tests/neg-custom-args/captures/byname.check   | 26 ++++----------
 tests/neg-custom-args/captures/byname.scala   |  4 +--
 tests/neg-custom-args/captures/i21920.check   | 10 ++++++
 tests/neg-custom-args/captures/i21920.scala   | 36 +++++++++++++++++++
 6 files changed, 62 insertions(+), 21 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/i21920.check
 create mode 100644 tests/neg-custom-args/captures/i21920.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
index eca3928569f1..0bf2dc107ce9 100644
--- a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
@@ -103,6 +103,9 @@ class ElimByName extends MiniPhase, InfoTransformer:
     Closure(meth,
         _ => arg.changeOwnerAfter(ctx.owner, meth, thisPhase),
         targetType = defn.ByNameFunction(argType)
+          // Note: this will forget any captures on the original by-name type
+          // But that's not a problem since we treat these closures specially
+          // anyway during recheck.
       ).withSpan(arg.span)
 
   private def isByNameRef(tree: Tree)(using Context): Boolean =
diff --git a/compiler/src/dotty/tools/dotc/transform/Recheck.scala b/compiler/src/dotty/tools/dotc/transform/Recheck.scala
index b7e4b9b14c92..d3173cef252d 100644
--- a/compiler/src/dotty/tools/dotc/transform/Recheck.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Recheck.scala
@@ -387,6 +387,10 @@ abstract class Recheck extends Phase, SymTransformer:
     def recheckClosure(tree: Closure, pt: Type, forceDependent: Boolean = false)(using Context): Type =
       if tree.tpt.isEmpty then
         tree.meth.tpe.widen.toFunctionType(tree.meth.symbol.is(JavaDefined), alwaysDependent = forceDependent)
+      else if defn.isByNameFunction(tree.tpt.tpe) then
+        val mt @ MethodType(Nil) = tree.meth.tpe.widen: @unchecked
+        val cmt = ContextualMethodType(Nil, Nil, mt.resultType)
+        cmt.toFunctionType(alwaysDependent = forceDependent)
       else
         recheck(tree.tpt)
 
diff --git a/tests/neg-custom-args/captures/byname.check b/tests/neg-custom-args/captures/byname.check
index c9530f6aad50..1c113591922d 100644
--- a/tests/neg-custom-args/captures/byname.check
+++ b/tests/neg-custom-args/captures/byname.check
@@ -1,3 +1,10 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/byname.scala:10:6 ----------------------------------------
+10 |  h(f2())  // error
+   |    ^^^^
+   |    Found:    (x$0: Int) ->{cap1} Int
+   |    Required: (x$0: Int) ->? Int
+   |
+   | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/byname.scala:19:5 -------------------------------------------------------------
 19 |  h(g()) // error
    |    ^^^
@@ -8,22 +15,3 @@
    |           ^^^
    |           reference (cap2 : Cap^) is not included in the allowed capture set {cap1}
    |           of an enclosing function literal with expected type () ->{cap1} I
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/byname.scala:4:2 -----------------------------------------
- 4 |  def f() = if cap1 == cap1 then g else g // error
-   |  ^
-   |  Found:    ((x$0: Int) ->{cap2} Int)^{}
-   |  Required: Int -> Int
-   |
-   |  Note that the expected type Int ->{} Int
-   |  is the previously inferred result type of method test
-   |  which is also the type seen in separately compiled sources.
-   |  The new inferred type ((x$0: Int) ->{cap2} Int)^{}
-   |  must conform to this type.
- 5 |  def g(x: Int) = if cap2 == cap2 then 1 else x
- 6 |  def g2(x: Int) = if cap1 == cap1 then 1 else x
- 7 |  def f2() = if cap1 == cap1 then g2 else g2
- 8 |  def h(ff: => Int ->{cap2} Int) = ff
- 9 |  h(f())
-10 |  h(f2())
-   |
-   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/byname.scala b/tests/neg-custom-args/captures/byname.scala
index 75ad527dbd2d..dd8fcf1b8818 100644
--- a/tests/neg-custom-args/captures/byname.scala
+++ b/tests/neg-custom-args/captures/byname.scala
@@ -1,13 +1,13 @@
 class Cap extends caps.Capability
 
 def test(cap1: Cap, cap2: Cap) =
-  def f() = if cap1 == cap1 then g else g // error
+  def f() = if cap1 == cap1 then g else g
   def g(x: Int) = if cap2 == cap2 then 1 else x
   def g2(x: Int) = if cap1 == cap1 then 1 else x
   def f2() = if cap1 == cap1 then g2 else g2
   def h(ff: => Int ->{cap2} Int) = ff
   h(f())
-  h(f2())
+  h(f2())  // error
 
 class I
 
diff --git a/tests/neg-custom-args/captures/i21920.check b/tests/neg-custom-args/captures/i21920.check
new file mode 100644
index 000000000000..8efa24426d01
--- /dev/null
+++ b/tests/neg-custom-args/captures/i21920.check
@@ -0,0 +1,10 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i21920.scala:34:34 ---------------------------------------
+34 |  val cell: Cell[File] = File.open(f => Cell(Seq(f))) // error
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                         Found:    Cell[box File^{f, f²}]{val head: () ?->? IterableOnce[box File^{f, f²}]^?}^?
+   |                         Required: Cell[File]
+   |
+   |                         where:    f  is a reference to a value parameter
+   |                                   f² is a reference to a value parameter
+   |
+   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/i21920.scala b/tests/neg-custom-args/captures/i21920.scala
new file mode 100644
index 000000000000..7ea5a63969b1
--- /dev/null
+++ b/tests/neg-custom-args/captures/i21920.scala
@@ -0,0 +1,36 @@
+import language.experimental.captureChecking
+
+trait Iterator[+A] extends IterableOnce[A]:
+  self: Iterator[A]^ =>
+  def next(): A
+
+trait IterableOnce[+A] extends Any:
+  def iterator: Iterator[A]^{this}
+
+final class Cell[A](head: => IterableOnce[A]^):
+  def headIterator: Iterator[A]^{this} = head.iterator
+
+class File private ():
+  private var closed = false
+
+  def close() = closed = true
+
+  def read() =
+    assert(!closed, "File closed")
+    1
+
+object File:
+  def open[T](f: File^ => T): T =
+    val file = File()
+    try
+      f(file)
+    finally
+      file.close()
+
+object Seq:
+  def apply[A](xs: A*): IterableOnce[A] = ???
+
+@main def Main() =
+  val cell: Cell[File] = File.open(f => Cell(Seq(f))) // error
+  val file = cell.headIterator.next()
+  file.read()

From d8ea08df1367f8073606b0de44ac80489e4ac9e4 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 12 Nov 2024 14:59:59 +0100
Subject: [PATCH 226/306] Polish and comment Setup class

---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  |   1 +
 .../src/dotty/tools/dotc/cc/Existential.scala |   1 +
 compiler/src/dotty/tools/dotc/cc/Setup.scala  | 238 ++++++++++++------
 3 files changed, 160 insertions(+), 80 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index b19e46de5cf1..2b0d89d9703e 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -592,6 +592,7 @@ extension (sym: Symbol)
     && !defn.isPolymorphicAfterErasure(sym)
     && !defn.isTypeTestOrCast(sym)
 
+  /** It's a parameter accessor that is not annotated @constructorOnly or @uncheckedCaptures */
   def isRefiningParamAccessor(using Context): Boolean =
     sym.is(ParamAccessor)
     && {
diff --git a/compiler/src/dotty/tools/dotc/cc/Existential.scala b/compiler/src/dotty/tools/dotc/cc/Existential.scala
index d51ce1b08dbd..ea979e0b9f7f 100644
--- a/compiler/src/dotty/tools/dotc/cc/Existential.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Existential.scala
@@ -337,6 +337,7 @@ object Existential:
     if needsWrap then wrapped else tp
   end mapCap
 
+  /** Map `cap` in function results to fresh existentials */
   def mapCapInResults(fail: Message => Unit)(using Context): TypeMap = new:
 
     def mapFunOrMethod(tp: Type, args: List[Type], res: Type): Type =
diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index 647e5a2cfd51..33ccea7c9995 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -13,7 +13,7 @@ import ast.tpd, tpd.*
 import transform.{PreRecheck, Recheck}, Recheck.*
 import CaptureSet.{IdentityCaptRefMap, IdempotentCaptRefMap}
 import Synthetics.isExcluded
-import util.Property
+import util.{Property, SimpleIdentitySet}
 import reporting.Message
 import printing.{Printer, Texts}, Texts.{Text, Str}
 import collection.mutable
@@ -22,6 +22,8 @@ import dotty.tools.dotc.util.NoSourcePosition
 
 /** Operations accessed from CheckCaptures */
 trait SetupAPI:
+
+  /** The operation to recheck a ValDef or DefDef */
   type DefRecheck = (tpd.ValOrDefDef, Symbol) => Context ?=> Type
 
   /** Setup procedure to run for each compilation unit
@@ -54,7 +56,9 @@ object Setup:
 end Setup
 import Setup.*
 
-/** A tree traverser that prepares a compilation unit to be capture checked.
+/** Phase that sets up everthing for capture checking.
+ *
+ *  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.
@@ -76,8 +80,16 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
   override def isRunnable(using Context) =
     super.isRunnable && Feature.ccEnabledSomewhere
 
+  /** A set containing symbols whose denotation is in train of being updated
+   *  Used to suppress transforming the denotations of these symbols.
+   */
   private val toBeUpdated = new mutable.HashSet[Symbol]
 
+  /** Drops `private` from the flags of `symd` provided it is
+   *  a parameter accessor that's not `constructorOnly` or `uncheckedCaptured`
+   *  and that contains at least one @retains in co- or in-variant position.
+   *  The @retains mught be implicit for a type deriving from `Capability`.
+   */
   private def newFlagsFor(symd: SymDenotation)(using Context): FlagSet =
 
     object containsCovarRetains extends TypeAccumulator[Boolean]:
@@ -101,30 +113,17 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     else symd.flags
   end newFlagsFor
 
+  /** Symbol is a term member of a class that was not capture checked
+   *  The info of these symbols is made fluid.
+   */
   def isPreCC(sym: Symbol)(using Context): Boolean =
     sym.isTerm && sym.maybeOwner.isClass
     && !sym.is(Module)
     && !sym.owner.is(CaptureChecked)
     && !defn.isFunctionSymbol(sym.owner)
 
-  private def fluidify(using Context) = new TypeMap with IdempotentCaptRefMap:
-    def apply(t: Type): Type = t match
-      case t: MethodType =>
-        mapOver(t)
-      case t: TypeLambda =>
-        t.derivedLambdaType(resType = this(t.resType))
-      case CapturingType(_, _) =>
-        t
-      case _ =>
-        val t1  = t match
-          case t @ defn.RefinedFunctionOf(rinfo: MethodType) =>
-            t.derivedRefinedType(t.parent, t.refinedName, this(rinfo))
-          case _ =>
-            mapOver(t)
-        if variance > 0 then t1
-        else decorate(t1, addedSet = Function.const(CaptureSet.Fluid))
-
-  /**  - Reset `private` flags of parameter accessors so that we can refine them
+  /** The symbol transformer of this phase.
+   *   - Resets `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.
    *  Enabled only until recheck is finished, and provided some compilation unit
@@ -134,7 +133,8 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     if !pastRecheck && Feature.ccEnabledSomewhere then
       val sym = symd.symbol
       def mappedInfo =
-        if toBeUpdated.contains(sym) then symd.info
+        if toBeUpdated.contains(sym)
+        then symd.info // don't transform symbols that will anyway be updated
         else transformExplicitType(symd.info)
       if Synthetics.needsTransform(symd) then
         Synthetics.transform(symd, mappedInfo)
@@ -183,7 +183,8 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
       case tp: MethodOrPoly => tp // don't box results of methods outside refinements
       case _ => recur(tp)
 
-  /** Perform the following transformation steps everywhere in a type:
+  /** Transform the type of an InferredTypeTree by performing the following transformation
+    * steps everywhere in the 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
@@ -202,8 +203,8 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
       override def toString = "map inferred"
 
       /** 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.
+       *  x_1: T_1, ..., x_n: T_n to C { val x_1: T_1^{CV_1}, ..., val x_n: T_n^{CV_n} }
+       *  where CV_1, ..., CV_n are fresh capture set variables.
        */
       def addCaptureRefinements(tp: Type): Type = tp match
         case _: TypeRef | _: AppliedType if refine && tp.typeParams.isEmpty =>
@@ -287,14 +288,22 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     try
       val tp1 = mapInferred(refine = true)(tp)
       val tp2 = Existential.mapCapInResults(_ => assert(false))(tp1)
-      if tp2 ne tp then capt.println(i"expanded implicit in ${ctx.owner}: $tp  -->  $tp1  -->  $tp2")
+      if tp2 ne tp then capt.println(i"expanded inferred in ${ctx.owner}: $tp  -->  $tp1  -->  $tp2")
       tp2
     catch case ex: AssertionError =>
       println(i"error while mapping inferred $tp")
       throw ex
   end transformInferredType
 
-  private def transformExplicitType(tp: Type, tptToCheck: Option[Tree] = None)(using Context): Type =
+  /** Transform an explicitly given type by performing the following transformation
+   *  steps everywhere in the type:
+   *   1. Expand throws aliases to contextual function type with CanThrow parameters
+   *   2. Map types with retains annotations to CapturingTypes
+   *   3. Add universal capture sets to types deriving from Capability
+   *   4. Map `cap` in function result types to existentially bound variables.
+   *   5. Schedule deferred well-formed tests for types with retains annotations.
+   */
+  private def transformExplicitType(tp: Type, tptToCheck: Tree = EmptyTree)(using Context): Type =
     val toCapturing = new DeepTypeMap:
       override def toString = "expand aliases"
 
@@ -323,6 +332,10 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           CapturingType(fntpe, cs, boxed = false)
         else fntpe
 
+      /** If C derives from Capability and we have a C^cs in source, we leave it as is
+       *  instead of expanding it to C^{cap}^cs. We do this by stripping capability-generated
+       *  universal capture sets from the parent of a CapturingType.
+       */
       def stripImpliedCaptureSet(tp: Type): Type = tp match
         case tp @ CapturingType(parent, refs)
         if (refs eq defn.universalCSImpliedByCapability) && !tp.isBoxedCapturing =>
@@ -338,7 +351,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
             val parent1 = this(parent)
             if ann.symbol.isRetains then
               val parent2 = stripImpliedCaptureSet(parent1)
-              for tpt <- tptToCheck do
+              if !tptToCheck.isEmpty then
                 checkWellformedLater(parent2, ann.tree, tpt)
               try
                 CapturingType(parent2, ann.tree.toCaptureSet)
@@ -357,7 +370,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     end toCapturing
 
     def fail(msg: Message) =
-      for tree <- tptToCheck do report.error(msg, tree.srcPos)
+      if !tptToCheck.isEmpty then report.error(msg, tptToCheck.srcPos)
 
     val tp1 = toCapturing(tp)
     val tp2 = Existential.mapCapInResults(fail)(tp1)
@@ -365,13 +378,13 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     tp2
   end transformExplicitType
 
-  /** Transform type of type tree, and remember the transformed type as the type the tree */
+  /** Transform type of tree, and remember the transformed type as the type the tree */
   private def transformTT(tree: TypeTree, boxed: Boolean)(using Context): Unit =
     if !tree.hasRememberedType then
       val transformed =
         if tree.isInferred
         then transformInferredType(tree.tpe)
-        else transformExplicitType(tree.tpe, tptToCheck = Some(tree))
+        else transformExplicitType(tree.tpe, tptToCheck = tree)
       tree.rememberType(if boxed then box(transformed) else transformed)
 
   /** Substitute parameter symbols in `from` to paramRefs in corresponding
@@ -417,27 +430,32 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     toBeUpdated += sym
     sym.updateInfo(thisPhase, info, newFlagsFor(sym))
     toBeUpdated -= sym
-    sym.namedType match
-      case ref: CaptureRef if ref.isTrackableRef => ref.invalidateCaches() // TODO: needed?
-      case _ =>
 
+  /** The info of `sym` at the CheckCaptures phase */
   extension (sym: Symbol) def nextInfo(using Context): Type =
     atPhase(thisPhase.next)(sym.info)
 
+  /** A traverser that adds knownTypes and updates symbol infos */
   def setupTraverser(recheckDef: DefRecheck) = new TreeTraverserWithPreciseImportContexts:
 
+    /** Transform the type of a val or var or the result type of a def */
     def transformResultType(tpt: TypeTree, sym: Symbol)(using Context): Unit =
+      // First step: Transform the type and record it as knownType of tpt.
       try
         transformTT(tpt,
             boxed =
               sym.is(Mutable, butNot = Method)
                 && !ccConfig.useSealed
                 && !sym.hasAnnotation(defn.UncheckedCapturesAnnot),
-              // types of mutable variables are boxed in pre 3.3 code
+              // Under the sealed policy, we disallow root capabilities in the type of mutable
+              // variables, no need to box them here.
           )
       catch case ex: IllegalCaptureRef =>
         capt.println(i"fail while transforming result type $tpt of $sym")
         throw ex
+
+      // Second step: Add descriptions for all capture set variables created in
+      // step one stating that they belong to `sym`.
       val addDescription = new TypeTraverser:
         def traverse(tp: Type) = tp match
           case tp @ CapturingType(parent, refs) =>
@@ -447,6 +465,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           case _ =>
             traverseChildren(tp)
       addDescription.traverse(tpt.knownType)
+    end transformResultType
 
     def traverse(tree: Tree)(using Context): Unit =
       tree match
@@ -461,7 +480,6 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
               paramss.foreach(traverse)
               transformResultType(tpt, meth)
               traverse(tree.rhs)
-              //println(i"TYPE of ${tree.symbol.showLocated} = ${tpt.knownType}")
 
         case tree @ ValDef(_, tpt: TypeTree, _) =>
           val sym = tree.symbol
@@ -469,7 +487,6 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           val defCtx = if sym.isOneOf(TermParamOrAccessor) then ctx else ctx.withOwner(sym)
           inContext(defCtx):
             transformResultType(tpt, sym)
-            capt.println(i"mapped $tree = ${tpt.knownType}")
             traverse(tree.rhs)
 
         case tree @ TypeApply(fn, args) =>
@@ -498,30 +515,33 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
       checkProperUse(tree)
     end traverse
 
+    /** Processing done on node `tree` after its children are traversed */
     def postProcess(tree: Tree)(using Context): Unit = tree match
       case tree: TypeTree =>
         transformTT(tree, boxed = false)
       case tree: ValOrDefDef =>
+        // Make sure denotation of tree's symbol is correct
         val sym = tree.symbol
 
-        /** The return type of a constructor instantiated with local type and value
-         *  parameters. Constructors have `unit` result type, that's why we can't
-         *  get this type by reading the result type tree, and have to construct it
-         *  explicitly.
-         */
+        // The return type of a constructor instantiated with local type and value
+        // parameters. Constructor defs have `Unit` as result type tree, that's why
+        // we can't get this type by reading the result type tree, and have to construct
+        // it explicitly.
         def constrReturnType(info: Type, psymss: List[List[Symbol]]): Type = info match
           case info: MethodOrPoly =>
             constrReturnType(info.instantiate(psymss.head.map(_.namedType)), psymss.tail)
           case _ =>
             info
 
-        /** The local result type, which is the known type of the result type tree,
-         *  with special treatment for constructors.
-         */
+        // The local result type, which is the known type of the result type tree,
+        // with special treatment for constructors.
         def localReturnType =
           if sym.isConstructor then constrReturnType(sym.info, sym.paramSymss)
           else tree.tpt.knownType
 
+        // A test whether parameter signature might change. This returns true if one of
+        // the parameters has a remembered type. The idea here is that we store a remembered
+        // type only if the transformed type is different from the original.
         def paramSignatureChanges = tree.match
           case tree: DefDef =>
             tree.paramss.nestedExists:
@@ -535,7 +555,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           tree.tpt.hasRememberedType && !sym.isConstructor || paramSignatureChanges
 
         // Replace an existing symbol info with inferred types where capture sets of
-        // TypeParamRefs and TermParamRefs put in correspondence by BiTypeMaps with the
+        // TypeParamRefs and TermParamRefs are 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
@@ -572,6 +592,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
               if prevLambdas.isEmpty then resType
               else SubstParams(prevPsymss, prevLambdas)(resType)
 
+        // If there's a change in the signature, update the info of `sym`
         if sym.exists && signatureChanges then
           val newInfo =
             Existential.mapCapInResults(report.error(_, tree.srcPos)):
@@ -588,9 +609,9 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
                 // the expected type and only afterwards we recheck the definition
                 newInfo
               else new LazyType:
+                // infos of other methods are determined from their definitions, which
+                // are checked on demand
                 def complete(denot: SymDenotation)(using Context) =
-                  // infos of other methods are determined from their definitions which
-                  // are checked on demand
                   assert(ctx.phase == thisPhase.next, i"$sym")
                   capt.println(i"forcing $sym, printing = ${ctx.mode.is(Mode.Printing)}")
                   //if ctx.mode.is(Mode.Printing) then new Error().printStackTrace()
@@ -606,9 +627,11 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           case cls: ClassSymbol =>
             inNestedLevelUnless(cls.is(Module)):
               val cinfo @ ClassInfo(prefix, _, ps, decls, selfInfo) = cls.classInfo
-              def innerModule = cls.is(ModuleClass) && !cls.isStatic
+
+              // Compute new self type
+              def isInnerModule = cls.is(ModuleClass) && !cls.isStatic
               val selfInfo1 =
-                if (selfInfo ne NoType) && !innerModule then
+                if (selfInfo ne NoType) && !isInnerModule then
                   // if selfInfo is explicitly given then use that one, except if
                   // self info applies to non-static modules, these still need to be inferred
                   selfInfo
@@ -623,8 +646,12 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
                   // self types (to which we also add nested module classes), provided they are
                   // neither pure, nor are publicily extensible with an unconstrained self type.
                   CapturingType(cinfo.selfType, CaptureSet.Var(cls, level = currentLevel))
+
+              // Compute new parent types
               val ps1 = inContext(ctx.withOwner(cls)):
                 ps.mapConserve(transformExplicitType(_))
+
+              // Install new types and if it is a module class also update module object
               if (selfInfo1 ne selfInfo) || (ps1 ne ps) then
                 val newInfo = ClassInfo(prefix, cls, ps1, decls, selfInfo1)
                 updateInfo(cls, newInfo)
@@ -639,6 +666,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
       case _ =>
     end postProcess
 
+    /** Check that @use annotations only appear on parameters and not on anonymous function parameters */
     def checkProperUse(tree: Tree)(using Context): Unit = tree match
       case tree: MemberDef =>
         def useAllowed(sym: Symbol) =
@@ -650,7 +678,12 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     end checkProperUse
   end setupTraverser
 
-  /** Checks whether an abstract type could be impure. See also: [[needsVariable]]. */
+// --------------- Adding capture set variables ----------------------------------
+
+  /** Checks whether an abstract type or its bound could be impure. If that's the case,
+   *  the abstract type gets a capture set variable in `decorate`.
+   *  See also: [[needsVariable]].
+   */
   private def instanceCanBeImpure(tp: Type)(using Context): Boolean = {
     tp.dealiasKeepAnnots match
       case CapturingType(_, refs) =>
@@ -673,7 +706,13 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         false
   }.showing(i"instance can be impure $tp = $result", capt)
 
-  /** Should a capture set variable be added on type `tp`? */
+  /** Should a capture set variable be added on type `tp`?
+   *  Notable exceptions are:
+   *   - If type refers to a class which is Pure, or it is Any, it does not need a variable.
+   *   - If type is an abstract or parameter type we decide according to `instanceCanBeImpure`
+   *   - If type is a capturing type that has already a capture set variable or has
+   *     the universal capture set, it does not need a variable.
+   */
   def needsVariable(tp: Type)(using Context): Boolean = {
     tp.typeParams.isEmpty && tp.match
       case tp: (TypeRef | AppliedType) =>
@@ -705,6 +744,61 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         false
   }.showing(i"can have inferred capture $tp = $result", captDebug)
 
+  /** Add a capture set variable or <fluid> set to `tp` if necessary.
+   *  Dealias `tp` (but keep annotations and opaque types) if doing
+   *  so ends up adding a capture set.
+   *  @param tp     the type to add a capture set to
+   *  @param added  A function producing the added capture set from a set of initial elements.
+   */
+  def decorate(tp: Type, added: CaptureSet.Refs => CaptureSet)(using Context): Type =
+    if tp.typeSymbol == defn.FromJavaObjectSymbol then
+      // For capture checking, we assume Object from Java is the same as Any
+      tp
+    else
+      def maybeAdd(target: Type, fallback: Type) =
+        if needsVariable(target) then
+          target match
+            case CapturingType(_, CaptureSet.Fluid) =>
+              target
+            case CapturingType(target1, cs1) if cs1.isConst =>
+              CapturingType(target1, added(cs1.elems))
+            case _ =>
+              CapturingType(target, added(SimpleIdentitySet.empty))
+        else fallback
+      val dealiased = tp.dealiasKeepAnnotsAndOpaques
+      if dealiased ne tp then
+        val transformed = transformInferredType(dealiased)
+        maybeAdd(transformed, if transformed ne dealiased then transformed else tp)
+      else maybeAdd(tp, tp)
+
+  /** Add a capture set variable to `tp` if necessary. */
+  private def addVar(tp: Type, owner: Symbol)(using Context): Type =
+    decorate(tp, CaptureSet.Var(owner, _, level = currentLevel))
+
+  /** A map that adds <fluid> capture sets at all contra- and invariant positions
+   *  in a type where a capture set would be needed. This is used to make types
+   *  that were not capture checked compatible with types that are capture checked.
+   *  We don't need to add <fluid> in covariant positions since pure types are
+   *  anyway compatible with capturing types.
+   */
+  private def fluidify(using Context) = new TypeMap with IdempotentCaptRefMap:
+    def apply(t: Type): Type = t match
+      case t: MethodType =>
+        mapOver(t)
+      case t: TypeLambda =>
+        t.derivedLambdaType(resType = this(t.resType))
+      case CapturingType(_, _) =>
+        t
+      case _ =>
+        val t1  = t match
+          case t @ defn.RefinedFunctionOf(rinfo: MethodType) =>
+            // Just refine the apply method, don't bother with the parent
+            t.derivedRefinedType(t.parent, t.refinedName, this(rinfo))
+          case _ =>
+            mapOver(t)
+        if variance > 0 then t1
+        else decorate(t1, Function.const(CaptureSet.Fluid))
+
   /** Pull out an embedded capture set from a part of `tp` */
   def normalizeCaptures(tp: Type)(using Context): Type = tp match
     case tp @ RefinedType(parent @ CapturingType(parent1, refs), rname, rinfo) =>
@@ -736,32 +830,9 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     case _ =>
       tp
 
-  /** Add a capture set variable to `tp` if necessary, or maybe pull out
-   *  an embedded capture set variable from a part of `tp`.
-   */
-  def decorate(tp: Type, addedSet: Type => CaptureSet)(using Context): Type =
-    if tp.typeSymbol == defn.FromJavaObjectSymbol then
-      // For capture checking, we assume Object from Java is the same as Any
-      tp
-    else
-      def maybeAdd(target: Type, fallback: Type) =
-        if needsVariable(target) then CapturingType(target, addedSet(target))
-        else fallback
-      val dealiased = tp.dealiasKeepAnnotsAndOpaques
-      if dealiased ne tp then
-        val transformed = transformInferredType(dealiased)
-        maybeAdd(transformed, if transformed ne dealiased then transformed else tp)
-      else maybeAdd(tp, tp)
-
-  /** Add a capture set variable to `tp` if necessary, or maybe pull out
-   *  an embedded capture set variable from a part of `tp`.
+  /** Run setup on a compilation unit with given `tree`.
+   *  @param recheckDef   the function to run for completing a val or def
    */
-  private def addVar(tp: Type, owner: Symbol)(using Context): Type =
-    decorate(tp,
-      addedSet = _.dealias.match
-        case CapturingType(_, refs) => CaptureSet.Var(owner, refs.elems, level = currentLevel)
-        case _ => CaptureSet.Var(owner, level = currentLevel))
-
   def setupUnit(tree: Tree, recheckDef: DefRecheck)(using Context): Unit =
     setupTraverser(recheckDef).traverse(tree)(using ctx.withPhase(thisPhase))
 
@@ -776,8 +847,11 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
    *  This check is performed after capture sets are computed in phase cc.
    *  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.
+   *  @param parent   the parent of the capturing type
+   *  @param ann      the original retains annotation
+   *  @param tpt      the tree for which an error or warning should be reported
    */
-  private def checkWellformedPost(parent: Type, ann: Tree, tpt: Tree)(using Context): Unit =
+  private def checkWellformed(parent: Type, ann: Tree, tpt: Tree)(using Context): Unit =
     capt.println(i"checkWF post $parent ${ann.retainedElems} in $tpt")
     var retained = ann.retainedElems.toArray
     for i <- 0 until retained.length do
@@ -806,14 +880,18 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         check(remaining, remaining)
       end for
     end for
-  end checkWellformedPost
+  end checkWellformed
 
-  /** Check well formed at post check time */
+  /** Check well formed at post check time. We need to wait until after
+   *  recheck because we find out only then whether capture sets are empty or
+   *  capture references are redundant.
+   */
   private def checkWellformedLater(parent: Type, ann: Tree, tpt: Tree)(using Context): Unit =
     if !tpt.span.isZeroExtent && enclosingInlineds.isEmpty then
       todoAtPostCheck += (ctx1 =>
-        checkWellformedPost(parent, ann, tpt)(using ctx1.withOwner(ctx.owner)))
+        checkWellformed(parent, ann, tpt)(using ctx1.withOwner(ctx.owner)))
 
+  /** Run all well formedness tests that were deferred to post check */
   def postCheck()(using Context): Unit =
     for chk <- todoAtPostCheck do chk(ctx)
     todoAtPostCheck.clear()

From e309d5a541474c9dfec01320438098af72f91ec0 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Fri, 15 Nov 2024 18:26:12 +0100
Subject: [PATCH 227/306] Some tweaks after code walkthrough

---
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 28 ++++---------------
 1 file changed, 6 insertions(+), 22 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 8b811bf61809..4b969ad360c9 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -259,7 +259,7 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  is that it is sometimes better for type inference to not constrain too early
      *  with a checkConformsExpr.
      */
-    private var todoAtPostCheck = new mutable.ListBuffer[() => Unit]
+    private val todoAtPostCheck = new mutable.ListBuffer[() => Unit]
 
     override def keepType(tree: Tree) =
       super.keepType(tree)
@@ -453,8 +453,8 @@ class CheckCaptures extends Recheck, SymTransformer:
             val isVisible = c.pathRoot match
               case ref: NamedType => isVisibleFromEnv(ref.symbol.owner, env)
               case ref: ThisType => isVisibleFromEnv(ref.cls, env)
-              case ref =>
-                false
+              case ref => false
+
             if !isVisible then
               if ccConfig.deferredReaches
               then avoidLocalCapability(c, env, lastEnv)
@@ -603,22 +603,6 @@ class CheckCaptures extends Recheck, SymTransformer:
           case _ => formal
       funtpe.derivedLambdaType(paramInfos = paramInfosWithUses)
 
-    /** If this is an application of a caps.unsafe method, handle it specially
-     *  otherwise return NoType.
-     */
-    private def recheckUnsafeApply(tree: Apply, pt: Type)(using Context): Type =
-      val meth = tree.fun.symbol
-      if meth == defn.Caps_unsafeAssumePure then
-        val arg :: Nil = tree.args: @unchecked
-        val argType0 = recheck(arg, pt.capturing(CaptureSet.universal))
-        val argType =
-          if argType0.captureSet.isAlwaysEmpty then argType0
-          else argType0.widen.stripCapturing
-        capt.println(i"rechecking $arg with $pt: $argType")
-        super.recheckFinish(argType, tree, pt)
-      else NoType
-    end recheckUnsafeApply
-
     /** Recheck applications, with special handling of unsafeAssumePure.
      *  More work is done in `recheckApplication`, `recheckArg` and `instantiate` below.
      */
@@ -667,7 +651,7 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  is the capture set of the argument.
      *  If the function `f` does have an `@use` parameter, then it could in addition
      *  unbox reach capabilities over its formal parameter. Therefore, the approximation
-     *  would be `Cq \union dcs(Ca)` instead.
+     *  would be `Cq \union dcs(Ta)` instead.
      *  If the approximation might subcapture the declared result Cr, we pick it for C
      *  otherwise we pick Cr.
      */
@@ -741,7 +725,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         for (getterName, argType) <- mt.paramNames.lazyZip(argTypes) do
           val getter = cls.info.member(getterName).suchThat(_.isRefiningParamAccessor).symbol
           if !getter.is(Private) && getter.hasTrackedParts then
-            refined = RefinedType(refined, getterName, argType.unboxed)
+            refined = RefinedType(refined, getterName, argType.unboxed) // Yichen you might want to check this
             allCaptures ++= argType.captureSet
         (refined, allCaptures)
 
@@ -783,7 +767,7 @@ class CheckCaptures extends Recheck, SymTransformer:
     end recheckTypeApply
 
     /** Faced with a tree of form `caps.contansImpl[CS, r.type]`, check that `R` is a tracked
-     *  capability and assert that `{r} <:CS`.
+     *  capability and assert that `{r} <: CS`.
      */
     def checkContains(tree: TypeApply)(using Context): Unit = tree match
       case ContainsImpl(csArg, refArg) =>

From 6f51fc0825aaeafcc7d42123107313453585cfd8 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Thu, 21 Nov 2024 19:31:38 +0100
Subject: [PATCH 228/306] Address review comments

---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala     |  5 ++---
 .../src/dotty/tools/dotc/cc/CaptureSet.scala     |  2 +-
 .../src/dotty/tools/dotc/cc/CheckCaptures.scala  | 16 +++++++---------
 .../tools/dotc/printing/RefinedPrinter.scala     |  2 +-
 tests/neg-custom-args/captures/bad-uses-2.scala  |  3 ++-
 5 files changed, 13 insertions(+), 15 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index 2b0d89d9703e..bc4eb92234eb 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -269,10 +269,9 @@ extension (tp: Type)
       tp
 
   /** The first element of this path type */
-  final def pathRoot(using Context): Type = tp.dealiasKeepAnnots match
+  final def pathRoot(using Context): Type = tp.dealias match
     case tp1: NamedType if tp1.symbol.owner.isClass => tp1.prefix.pathRoot
-    case ReachCapability(tp1) => tp1.pathRoot
-    case _ => tp
+    case tp1 => tp1
 
   /** If this part starts with `C.this`, the class `C`.
    *  Otherwise, if it starts with a reference `r`, `r`'s owner.
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
index 675b00a09ff5..5be4f6a2d1cd 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
@@ -1137,7 +1137,7 @@ object CaptureSet:
             seen += t.symbol
             val upper = t.info.bounds.hi
             if includeTypevars && upper.isExactlyAny then CaptureSet.universal
-            else this(cs, t.info.bounds.hi)
+            else this(cs, upper)
           case t @ FunctionOrMethod(args, res @ Existential(_, _))
           if args.forall(_.isAlwaysPure) =>
             this(cs, Existential.toCap(res))
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 4b969ad360c9..23e7d8f8ecf8 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -380,10 +380,12 @@ class CheckCaptures extends Recheck, SymTransformer:
       // A captured reference with the symbol `sym` is visible from the environment
       // if `sym` is not defined inside the owner of the environment.
       inline def isVisibleFromEnv(sym: Symbol, env: Env) =
-        if env.kind == EnvKind.NestedInOwner then
-          !sym.isProperlyContainedIn(env.owner)
-        else
-          !sym.isContainedIn(env.owner)
+        sym.exists && {
+          if env.kind == EnvKind.NestedInOwner then
+            !sym.isProperlyContainedIn(env.owner)
+          else
+            !sym.isContainedIn(env.owner)
+        }
 
       /** If captureRef `c` refers to a parameter that is not @use declared, report an error.
        *  Exception under deferredReaches: If use comes from a nested closure, accept it.
@@ -450,11 +452,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           // Only captured references that are visible from the environment
           // should be included.
           val included = cs.filter: c =>
-            val isVisible = c.pathRoot match
-              case ref: NamedType => isVisibleFromEnv(ref.symbol.owner, env)
-              case ref: ThisType => isVisibleFromEnv(ref.cls, env)
-              case ref => false
-
+            val isVisible = isVisibleFromEnv(c.pathOwner, env)
             if !isVisible then
               if ccConfig.deferredReaches
               then avoidLocalCapability(c, env, lastEnv)
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 95a0007c1dfe..a399b8173b5d 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -30,7 +30,7 @@ import config.SourceVersion.*
 
 import dotty.tools.dotc.util.SourcePosition
 import dotty.tools.dotc.ast.untpd.{MemberDef, Modifiers, PackageDef, RefTree, Template, TypeDef, ValOrDefDef}
-import cc.{CaptureSet, CapturingType, toCaptureSet, IllegalCaptureRef, isRetains, ReachCapability, MaybeCapability, Existential}
+import cc.*
 import dotty.tools.dotc.parsing.JavaParsers
 
 class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
diff --git a/tests/neg-custom-args/captures/bad-uses-2.scala b/tests/neg-custom-args/captures/bad-uses-2.scala
index 00eec3e5a2e9..8dd121b2b134 100644
--- a/tests/neg-custom-args/captures/bad-uses-2.scala
+++ b/tests/neg-custom-args/captures/bad-uses-2.scala
@@ -3,4 +3,5 @@ class Test:
   @use def F = ???  // error
   @use val x = ???  // error
   @use type T       // error
-  def foo(@use c: Test): Unit = ??? // OK
+  def foo[@use T](@use c: T): Unit = ??? // OK
+

From da14277dd764ea08cac36002d3cf8ea58c4c611f Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Thu, 21 Nov 2024 19:41:59 +0100
Subject: [PATCH 229/306] Fix rebase breakage

---
 compiler/src/dotty/tools/dotc/cc/Setup.scala    | 4 ++--
 tests/neg-custom-args/captures/use-capset.check | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index 33ccea7c9995..dfb9ec70bdba 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -352,11 +352,11 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
             if ann.symbol.isRetains then
               val parent2 = stripImpliedCaptureSet(parent1)
               if !tptToCheck.isEmpty then
-                checkWellformedLater(parent2, ann.tree, tpt)
+                checkWellformedLater(parent2, ann.tree, tptToCheck)
               try
                 CapturingType(parent2, ann.tree.toCaptureSet)
               catch case ex: IllegalCaptureRef =>
-                report.error(em"Illegal capture reference: ${ex.getMessage.nn}", tptToCheck.fold(NoSourcePosition)(_.srcPos))
+                report.error(em"Illegal capture reference: ${ex.getMessage.nn}", tptToCheck.srcPos)
                 parent2
             else
               t.derivedAnnotatedType(parent1, ann)
diff --git a/tests/neg-custom-args/captures/use-capset.check b/tests/neg-custom-args/captures/use-capset.check
index 4002e6569c94..cb330daf67f8 100644
--- a/tests/neg-custom-args/captures/use-capset.check
+++ b/tests/neg-custom-args/captures/use-capset.check
@@ -13,7 +13,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/use-capset.scala:15:50 -----------------------------------
 15 |  val _: () -> List[Object^{io}] -> Object^{io} = h2 // error, should be ->{io}
    |                                                  ^^
-   |                                      Found:    (h2 : () ->? (x$0: List[box Object^{io}]^{}) ->{io} Object^{io})
-   |                                      Required: () -> List[box Object^{io}] -> Object^{io}
+   |                                          Found:    (h2 : () ->? (x$0: List[box Object^]^{}) ->{io} Object^{io})
+   |                                          Required: () -> List[box Object^{io}] -> Object^{io}
    |
    | longer explanation available when compiling with `-explain`

From 353f80b416356b9b32e69edcc2b93847a298045b Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Fri, 22 Nov 2024 15:05:58 +0100
Subject: [PATCH 230/306] Fix more rebase breakage

---
 tests/neg-custom-args/captures/lazylist.check | 2 +-
 tests/neg-custom-args/captures/real-try.check | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/tests/neg-custom-args/captures/lazylist.check b/tests/neg-custom-args/captures/lazylist.check
index bc95a445f3f4..65fed0c4ec7e 100644
--- a/tests/neg-custom-args/captures/lazylist.check
+++ b/tests/neg-custom-args/captures/lazylist.check
@@ -29,7 +29,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylist.scala:41:42 -------------------------------------
 41 |  val ref4c: LazyList[Int]^{cap1, ref3} = ref4 // error
    |                                          ^^^^
-   |                                          Found:    (ref4 : lazylists.LazyList[Int]^{cap3, cap2, ref1, cap1})
+   |                                          Found:    (ref4 : lazylists.LazyList[Int]^{cap3, ref1, ref2})
    |                                          Required: lazylists.LazyList[Int]^{cap1, ref3}
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/real-try.check b/tests/neg-custom-args/captures/real-try.check
index 12ea7262007a..7a4b12ac08f6 100644
--- a/tests/neg-custom-args/captures/real-try.check
+++ b/tests/neg-custom-args/captures/real-try.check
@@ -1,7 +1,7 @@
--- [E190] Potential Issue Warning: tests/neg-custom-args/captures/real-try.scala:38:4 ----------------------------------
-38 |  b.x
-   |  ^^^
-   |  Discarded non-Unit value of type () -> Unit. Add `: Unit` to discard silently.
+-- [E190] Potential Issue Warning: tests/neg-custom-args/captures/real-try.scala:38:2 ----------------------------------
+38 |  b
+   |  ^
+   |  Discarded non-Unit value of type Cell[() -> Unit]. Add `: Unit` to discard silently.
    |
    | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/real-try.scala:14:2 -----------------------------------------------------------

From 1e8bbcae29a3c4caa3ad096eb6d53e038631ab45 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 25 Nov 2024 13:08:31 +0000
Subject: [PATCH 231/306] Bump VirtusLab/scala-cli-setup from 1.5.3 to 1.5.4

Bumps [VirtusLab/scala-cli-setup](https://github.com/virtuslab/scala-cli-setup) from 1.5.3 to 1.5.4.
- [Release notes](https://github.com/virtuslab/scala-cli-setup/releases)
- [Commits](https://github.com/virtuslab/scala-cli-setup/compare/v1.5.3...v1.5.4)

---
updated-dependencies:
- dependency-name: VirtusLab/scala-cli-setup
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/lts-backport.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/lts-backport.yaml b/.github/workflows/lts-backport.yaml
index 24d2329ed9da..b26075c180e9 100644
--- a/.github/workflows/lts-backport.yaml
+++ b/.github/workflows/lts-backport.yaml
@@ -15,7 +15,7 @@ jobs:
         with:
           fetch-depth: 0
       - uses: coursier/cache-action@v6
-      - uses: VirtusLab/scala-cli-setup@v1.5.3
+      - uses: VirtusLab/scala-cli-setup@v1.5.4
       - run: scala-cli ./project/scripts/addToBackportingProject.scala -- ${{ github.sha }}
         env:
           GRAPHQL_API_TOKEN: ${{ secrets.GRAPHQL_API_TOKEN }}

From e89a66cefb21dd83245748859c3869ab09c06f94 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Mon, 25 Nov 2024 16:38:36 +0100
Subject: [PATCH 232/306] Make context bounds for poly functions a standard
 feature (#22019)

closes #22017
---
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala | 2 +-
 tests/pos/contextbounds-for-poly-functions.scala    | 3 ---
 tests/run/contextbounds-for-poly-functions.scala    | 3 ---
 3 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 2e441553689c..ca8ebaf79b09 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -3491,7 +3491,7 @@ object Parsers {
           val hkparams = typeParamClauseOpt(ParamOwner.Hk)
           val bounds =
             if paramOwner.acceptsCtxBounds then typeAndCtxBounds(name)
-            else if in.featureEnabled(Feature.modularity) && paramOwner == ParamOwner.Type then typeAndCtxBounds(name)
+            else if sourceVersion.isAtLeast(`3.6`) && paramOwner == ParamOwner.Type then typeAndCtxBounds(name)
             else typeBounds()
           TypeDef(name, lambdaAbstract(hkparams, bounds)).withMods(mods)
         }
diff --git a/tests/pos/contextbounds-for-poly-functions.scala b/tests/pos/contextbounds-for-poly-functions.scala
index 13411a3ad769..49975cf8591d 100644
--- a/tests/pos/contextbounds-for-poly-functions.scala
+++ b/tests/pos/contextbounds-for-poly-functions.scala
@@ -1,6 +1,3 @@
-import scala.language.experimental.modularity
-import scala.language.future
-
 trait Ord[X]:
   def compare(x: X, y: X): Int
   type T
diff --git a/tests/run/contextbounds-for-poly-functions.scala b/tests/run/contextbounds-for-poly-functions.scala
index dcc974fce198..72eed8939fcf 100644
--- a/tests/run/contextbounds-for-poly-functions.scala
+++ b/tests/run/contextbounds-for-poly-functions.scala
@@ -1,6 +1,3 @@
-import scala.language.experimental.modularity
-import scala.language.future
-
 trait Show[X]:
   def show(x: X): String
 

From 0afabd6e5a506cc833ff01d3000cc8f206ba8255 Mon Sep 17 00:00:00 2001
From: Piotr Chabelski <ged.subfan@gmail.com>
Date: Mon, 25 Nov 2024 23:45:03 +0100
Subject: [PATCH 233/306] Update Scala CLI to 1.5.4 (was 1.5.1) & `coursier` to
 2.1.18 (was 2.1.13) (#22021)

https://github.com/VirtusLab/scala-cli/releases/tag/v1.5.4
https://github.com/coursier/coursier/releases/tag/v2.1.18
cc @WojciechMazur
---
 project/Build.scala | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/project/Build.scala b/project/Build.scala
index f5593144a631..b2aca3705d83 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -162,9 +162,9 @@ object Build {
   val mimaPreviousLTSDottyVersion = "3.3.0"
 
   /** Version of Scala CLI to download */
-  val scalaCliLauncherVersion = "1.5.1"
+  val scalaCliLauncherVersion = "1.5.4"
   /** Version of Coursier to download for initializing the local maven repo of Scala command */
-  val coursierJarVersion = "2.1.13"
+  val coursierJarVersion = "2.1.18"
 
   object CompatMode {
     final val BinaryCompatible = 0

From 75ddad2c856aeff1d434bed699573c8070253cdb Mon Sep 17 00:00:00 2001
From: Mathias <mathiaslogins@gmail.com>
Date: Tue, 26 Nov 2024 04:54:03 -0500
Subject: [PATCH 234/306] [ISSUE-#19208] If scaladocs on file protocol don't do
 SPA routing. (#22013)

If we detect scaladocs are being served locally
(i.e page on the "file" protocol)
then we let the link click event go back to normal handling.

Otherwise unless a user has allowed pages on the file protocol to access
other files

https://github.com/chromium/chromium/blob/b6c23ba2056e65081f8a5bcbf73b176baaa42645/content/public/common/content_switches.cc#L15
for example with the allow-file-access-from-files flag in chrome then
SPA routing won't work.

Fixes #19208.
---
 scaladoc/resources/dotty_res/scripts/ux.js | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/scaladoc/resources/dotty_res/scripts/ux.js b/scaladoc/resources/dotty_res/scripts/ux.js
index 97f9bf14939d..29a610f62b0c 100644
--- a/scaladoc/resources/dotty_res/scripts/ux.js
+++ b/scaladoc/resources/dotty_res/scripts/ux.js
@@ -167,6 +167,11 @@ function attachAllListeners() {
       if (url.origin !== window.location.origin) {
         return;
       }
+      // ISSUE-19208, treat as normal link when lacking HTTP server,
+      // otherwise GET request blocked by CORS protections.
+      if (window.location.protocol.startsWith("file")) {
+        return;
+      }
       if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey || e.button !== 0) {
         return;
       }

From d4968e7805b9280df5a7073a2b9d42b161e8325e Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 26 Nov 2024 12:54:45 +0100
Subject: [PATCH 235/306] Fix .toTuple insertion

It previously did not follow aliases or upper bounds when deciding
whether something was a named tuple.
---
 .../src/dotty/tools/dotc/core/TypeUtils.scala |  9 +++++++++
 .../src/dotty/tools/dotc/typer/Typer.scala    |  2 +-
 tests/pos/named-tuple-downcast.scala          | 20 +++++++++++++++++++
 3 files changed, 30 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/named-tuple-downcast.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TypeUtils.scala b/compiler/src/dotty/tools/dotc/core/TypeUtils.scala
index f343d7227bf8..0a219fa6ddfd 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeUtils.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeUtils.scala
@@ -145,6 +145,15 @@ class TypeUtils:
       case defn.NamedTuple(_, _) => true
       case _ => false
 
+    def derivesFromNamedTuple(using Context): Boolean = self match
+      case defn.NamedTuple(_, _) => true
+      case tp: MatchType =>
+        tp.bound.derivesFromNamedTuple || tp.reduced.derivesFromNamedTuple
+      case tp: TypeProxy => tp.superType.derivesFromNamedTuple
+      case tp: AndType => tp.tp1.derivesFromNamedTuple || tp.tp2.derivesFromNamedTuple
+      case tp: OrType => tp.tp1.derivesFromNamedTuple && tp.tp2.derivesFromNamedTuple
+      case _ => false
+
     /** Drop all named elements in tuple type */
     def stripNamedTuple(using Context): Type = self.normalized.dealias match
       case defn.NamedTuple(_, vals) =>
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 13f7b4eb1726..1816d81ebdad 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -4641,7 +4641,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         case _: SelectionProto =>
           tree // adaptations for selections are handled in typedSelect
         case _ if ctx.mode.is(Mode.ImplicitsEnabled) && tree.tpe.isValueType =>
-          if tree.tpe.widen.isNamedTupleType && pt.derivesFrom(defn.TupleClass) then
+          if tree.tpe.derivesFromNamedTuple && pt.derivesFrom(defn.TupleClass) then
             readapt(typed(untpd.Select(untpd.TypedSplice(tree), nme.toTuple)))
           else if pt.isRef(defn.AnyValClass, skipRefined = false)
               || pt.isRef(defn.ObjectClass, skipRefined = false)
diff --git a/tests/pos/named-tuple-downcast.scala b/tests/pos/named-tuple-downcast.scala
new file mode 100644
index 000000000000..239089b60c3d
--- /dev/null
+++ b/tests/pos/named-tuple-downcast.scala
@@ -0,0 +1,20 @@
+type Person = (name: String, age: Int)
+
+val Bob: Person = (name = "Bob", age = 33)
+
+type SI = (String, Int)
+
+def id[X](x: X): X = x
+val x: (String, Int) = Bob
+val y: SI = id(Bob)
+val and: Person & String = ???
+val _: SI = and
+val or: Person | (name: "Bob", age: 33) = ???
+val _: SI = or
+
+class C[P <: Person](p: P):
+  val x: (String, Int) = p
+
+
+
+

From d7aceee85a634ba5a867f4af686bf6aa800b6120 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 26 Nov 2024 14:36:46 +0100
Subject: [PATCH 236/306] Tweak other occurrences of `isNamedTuple`

---
 compiler/src/dotty/tools/dotc/interactive/Completion.scala   | 2 +-
 compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala | 2 +-
 compiler/src/dotty/tools/dotc/typer/Implicits.scala          | 2 +-
 compiler/src/dotty/tools/dotc/typer/Typer.scala              | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/interactive/Completion.scala b/compiler/src/dotty/tools/dotc/interactive/Completion.scala
index 7a0a19552f48..ff5716b227ca 100644
--- a/compiler/src/dotty/tools/dotc/interactive/Completion.scala
+++ b/compiler/src/dotty/tools/dotc/interactive/Completion.scala
@@ -543,7 +543,7 @@ object Completion:
             .groupByName
 
       val qualTpe = qual.typeOpt
-      if qualTpe.isNamedTupleType then
+      if qualTpe.derivesFromNamedTuple then
         namedTupleCompletionsFromType(qualTpe)
       else if qualTpe.derivesFrom(defn.SelectableClass) then
         val pre = if !TypeOps.isLegalPrefix(qualTpe) then Types.SkolemType(qualTpe) else qualTpe
diff --git a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
index 9750c41b7252..ee608a4297bf 100644
--- a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
@@ -107,7 +107,7 @@ object PatternMatcher {
         // TODO: Drop Case once we use everywhere else `isPatmatGenerated`.
 
     private def dropNamedTuple(tree: Tree): Tree =
-      val tpe = tree.tpe.widen
+      val tpe = tree.tpe.widenDealias
       if tpe.isNamedTupleType then tree.cast(tpe.stripNamedTuple) else tree
 
     /** The plan `let x = rhs in body(x)` where `x` is a fresh variable */
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 0727c83d8469..228206d8fb1e 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -876,7 +876,7 @@ trait Implicits:
        || inferView(dummyTreeOfType(from), to)
             (using ctx.fresh.addMode(Mode.ImplicitExploration).setExploreTyperState()).isSuccess
           // TODO: investigate why we can't TyperState#test here
-       || from.widen.isNamedTupleType && to.derivesFrom(defn.TupleClass)
+       || from.widen.derivesFromNamedTuple && to.derivesFrom(defn.TupleClass)
            && from.widen.stripNamedTuple <:< to
        )
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 1816d81ebdad..96d57c644142 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2706,7 +2706,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             body1.isInstanceOf[RefTree] && !isWildcardArg(body1)
             || body1.isInstanceOf[Literal]
           val symTp =
-            if isStableIdentifierOrLiteral || pt.isNamedTupleType then pt
+            if isStableIdentifierOrLiteral || pt.dealias.isNamedTupleType then pt
               // need to combine tuple element types with expected named type
             else if isWildcardStarArg(body1)
                     || pt == defn.ImplicitScrutineeTypeRef

From 49f287ac081fb3d10a18fdcc56e2bfb75c5054d4 Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Tue, 26 Nov 2024 20:26:20 +0000
Subject: [PATCH 237/306] Do not lift annotation arguments

---
 .../src/dotty/tools/dotc/ast/TreeInfo.scala   |  4 +--
 .../tools/dotc/printing/RefinedPrinter.scala  |  2 +-
 .../dotty/tools/dotc/typer/Applications.scala |  7 +++++-
 .../dependent-annot-default-args.check        | 25 +++++++++++++++++++
 .../dependent-annot-default-args.scala        |  5 ++++
 5 files changed, 39 insertions(+), 4 deletions(-)
 create mode 100644 tests/printing/dependent-annot-default-args.check
 create mode 100644 tests/printing/dependent-annot-default-args.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index 09c855847fac..e0fe17755257 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -144,7 +144,7 @@ trait TreeInfo[T <: Untyped] { self: Trees.Instance[T] =>
   def allTermArguments(tree: Tree): List[Tree] = unsplice(tree) match {
     case Apply(fn, args) => allTermArguments(fn) ::: args
     case TypeApply(fn, args) => allTermArguments(fn)
-    case Block(_, expr) => allTermArguments(expr)
+    case Block(Nil, expr) => allTermArguments(expr)
     case _ => Nil
   }
 
@@ -152,7 +152,7 @@ trait TreeInfo[T <: Untyped] { self: Trees.Instance[T] =>
   def allArguments(tree: Tree): List[Tree] = unsplice(tree) match {
     case Apply(fn, args) => allArguments(fn) ::: args
     case TypeApply(fn, args) => allArguments(fn) ::: args
-    case Block(_, expr) => allArguments(expr)
+    case Block(Nil, expr) => allArguments(expr)
     case _ => Nil
   }
 
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index a399b8173b5d..b7f2eef8c8f9 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -1124,7 +1124,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     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))
+        val explicitArgs = args.filterNot(untpd.stripNamedArg(_).symbol.name.is(DefaultGetterName))
         recur(fn) ~ "(" ~ toTextGlobal(explicitArgs, ", ") ~ ")"
       case TypeApply(fn, args) => recur(fn) ~ "[" ~ toTextGlobal(args, ", ") ~ "]"
       case Select(qual, nme.CONSTRUCTOR) => recur(qual)
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index 5fb91694b8a6..41e48f7595dc 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -513,7 +513,7 @@ trait Applications extends Compatibility {
         case tp => args.size
       }
 
-      !isJavaAnnotConstr(methRef.symbol) &&
+      !isAnnotConstr(methRef.symbol) &&
       args.size < requiredArgNum(funType)
     }
 
@@ -662,6 +662,11 @@ trait Applications extends Compatibility {
     def isJavaAnnotConstr(sym: Symbol): Boolean =
       sym.is(JavaDefined) && sym.isConstructor && sym.owner.is(JavaAnnotation)
 
+
+    /** Is `sym` a constructor of an annotation? */
+    def isAnnotConstr(sym: Symbol): Boolean =
+      sym.isConstructor && sym.owner.isAnnotation
+
     /** Match re-ordered arguments against formal parameters
      *  @param n   The position of the first parameter in formals in `methType`.
      */
diff --git a/tests/printing/dependent-annot-default-args.check b/tests/printing/dependent-annot-default-args.check
new file mode 100644
index 000000000000..44c1fe31e2d1
--- /dev/null
+++ b/tests/printing/dependent-annot-default-args.check
@@ -0,0 +1,25 @@
+[[syntax trees at end of                     typer]] // tests/printing/dependent-annot-default-args.scala
+package <empty> {
+  class annot(x: Any, y: Any) extends annotation.Annotation() {
+    private[this] val x: Any
+    private[this] val y: Any
+  }
+  final lazy module val annot: annot = new annot()
+  final module class annot() extends AnyRef() { this: annot.type =>
+    def $lessinit$greater$default$2: Any @uncheckedVariance = 42
+  }
+  final lazy module val dependent-annot-default-args$package:
+    dependent-annot-default-args$package =
+    new dependent-annot-default-args$package()
+  final module class dependent-annot-default-args$package() extends Object() {
+    this: dependent-annot-default-args$package.type =>
+    def f(x: Int): Int @annot(x) = x
+    def test: Unit =
+      {
+        val y: Int = ???
+        val z: Int @annot(y) = f(y)
+        ()
+      }
+  }
+}
+
diff --git a/tests/printing/dependent-annot-default-args.scala b/tests/printing/dependent-annot-default-args.scala
new file mode 100644
index 000000000000..7ddce711fedc
--- /dev/null
+++ b/tests/printing/dependent-annot-default-args.scala
@@ -0,0 +1,5 @@
+class annot(x: Any, y: Any = 42) extends annotation.Annotation
+def f(x: Int): Int @annot(x) = x
+def test =
+  val y: Int = ???
+  val z = f(y)

From a4ea8bfb92142b86cd6a06071464ea8c66f7f2a7 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Wed, 27 Nov 2024 18:49:45 +0100
Subject: [PATCH 238/306] Make NamedTupls an experimental feature again

---
 .../src/dotty/tools/dotc/config/Feature.scala |  2 +
 .../dotty/tools/dotc/parsing/Parsers.scala    |  4 +-
 .../src/dotty/tools/dotc/typer/Typer.scala    |  2 +-
 .../named-tuples.md                           |  4 +-
 docs/sidebar.yml                              |  2 +-
 library/src/scala/NamedTuple.scala            |  3 +
 .../runtime/stdLibPatches/language.scala      |  1 -
 .../pc/tests/completion/CompletionSuite.scala |  6 +-
 tests/neg/i20517.check                        | 14 +--
 tests/neg/i20517.scala                        |  1 +
 tests/neg/infix-named-args.check              | 20 ++--
 tests/neg/infix-named-args.scala              |  2 +
 tests/neg/named-tuple-selectable.scala        |  2 +
 tests/neg/named-tuples-2.check                |  8 +-
 tests/neg/named-tuples-2.scala                |  1 +
 tests/neg/named-tuples-3.check                |  4 +-
 tests/neg/named-tuples-3.scala                |  2 +
 tests/neg/named-tuples.check                  | 92 +++++++++----------
 tests/neg/named-tuples.scala                  |  3 +-
 tests/new/test.scala                          |  2 +
 tests/pos/fieldsOf.scala                      |  2 +
 tests/pos/i20377.scala                        |  1 +
 tests/pos/i21300.scala                        |  6 +-
 tests/pos/i21413.scala                        |  2 +
 tests/pos/named-tuple-combinators.scala       |  1 +
 tests/pos/named-tuple-selectable.scala        |  1 +
 tests/pos/named-tuple-selections.scala        |  1 +
 tests/pos/named-tuple-unstable.scala          |  1 +
 tests/pos/named-tuple-widen.scala             |  1 +
 tests/pos/named-tuples-ops-mirror.scala       |  1 +
 tests/pos/named-tuples1.scala                 |  1 +
 tests/pos/namedtuple-src-incompat.scala       |  1 +
 tests/pos/tuple-ops.scala                     |  1 +
 tests/rewrites/infix-named-args.check         |  4 +-
 tests/rewrites/infix-named-args.scala         |  2 +
 .../stdlibExperimentalDefinitions.scala       |  6 ++
 tests/run/named-patmatch.scala                |  1 +
 tests/run/named-patterns.scala                |  1 +
 tests/run/named-tuple-ops.scala               |  1 +
 tests/run/named-tuples-xxl.scala              |  1 +
 tests/run/named-tuples.scala                  |  1 +
 tests/run/tyql.scala                          |  1 +
 tests/warn/21681.check                        |  4 +-
 tests/warn/21681.scala                        |  2 +
 tests/warn/21681b.check                       |  4 +-
 tests/warn/21681b.scala                       |  2 +
 tests/warn/21681c.check                       |  4 +-
 tests/warn/21681c.scala                       |  2 +
 tests/warn/21770.check                        |  4 +-
 tests/warn/21770.scala                        |  4 +-
 tests/warn/infix-named-args-migration.scala   |  2 +
 51 files changed, 150 insertions(+), 91 deletions(-)
 rename docs/_docs/reference/{other-new-features => experimental}/named-tuples.md (98%)

diff --git a/compiler/src/dotty/tools/dotc/config/Feature.scala b/compiler/src/dotty/tools/dotc/config/Feature.scala
index ad20bab46c1e..8b9a64924ace 100644
--- a/compiler/src/dotty/tools/dotc/config/Feature.scala
+++ b/compiler/src/dotty/tools/dotc/config/Feature.scala
@@ -34,6 +34,7 @@ object Feature:
   val pureFunctions = experimental("pureFunctions")
   val captureChecking = experimental("captureChecking")
   val into = experimental("into")
+  val namedTuples = experimental("namedTuples")
   val modularity = experimental("modularity")
   val betterMatchTypeExtractors = experimental("betterMatchTypeExtractors")
   val quotedPatternsWithPolymorphicFunctions = experimental("quotedPatternsWithPolymorphicFunctions")
@@ -65,6 +66,7 @@ object Feature:
     (pureFunctions, "Enable pure functions for capture checking"),
     (captureChecking, "Enable experimental capture checking"),
     (into, "Allow into modifier on parameter types"),
+    (namedTuples, "Allow named tuples"),
     (modularity, "Enable experimental modularity features"),
     (betterMatchTypeExtractors, "Enable better match type extractors"),
     (betterFors, "Enable improvements in `for` comprehensions")
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index ca8ebaf79b09..3ea4131d5d78 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -667,7 +667,7 @@ object Parsers {
       else leading :: Nil
 
     def maybeNamed(op: () => Tree): () => Tree = () =>
-      if isIdent && in.lookahead.token == EQUALS && sourceVersion.isAtLeast(`3.6`) then
+      if isIdent && in.lookahead.token == EQUALS && in.featureEnabled(Feature.namedTuples) then
         atSpan(in.offset):
           val name = ident()
           in.nextToken()
@@ -2172,7 +2172,7 @@ object Parsers {
 
       if namedOK && isIdent && in.lookahead.token == EQUALS then
         commaSeparated(() => namedArgType())
-      else if tupleOK && isIdent && in.lookahead.isColon && sourceVersion.isAtLeast(`3.6`) then
+      else if tupleOK && isIdent && in.lookahead.isColon && in.featureEnabled(Feature.namedTuples) then
         commaSeparated(() => namedElem())
       else
         commaSeparated(() => argType())
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 13f7b4eb1726..57a027653241 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -795,7 +795,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     def tryNamedTupleSelection() =
       val namedTupleElems = qual.tpe.widenDealias.namedTupleElementTypes
       val nameIdx = namedTupleElems.indexWhere(_._1 == selName)
-      if nameIdx >= 0 && sourceVersion.isAtLeast(`3.6`) then
+      if nameIdx >= 0 && Feature.enabled(Feature.namedTuples) then
         typed(
           untpd.Apply(
             untpd.Select(untpd.TypedSplice(qual), nme.apply),
diff --git a/docs/_docs/reference/other-new-features/named-tuples.md b/docs/_docs/reference/experimental/named-tuples.md
similarity index 98%
rename from docs/_docs/reference/other-new-features/named-tuples.md
rename to docs/_docs/reference/experimental/named-tuples.md
index 5483c5cc255b..27d74259725d 100644
--- a/docs/_docs/reference/other-new-features/named-tuples.md
+++ b/docs/_docs/reference/experimental/named-tuples.md
@@ -1,10 +1,10 @@
 ---
 layout: doc-page
 title: "Named Tuples"
-nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/named-tuples.html
+nightlyOf: https://docs.scala-lang.org/scala3/reference/experimental/named-tuples.html
 ---
 
-Starting in Scala 3.6, the elements of a tuple can be named. Example:
+The elements of a tuple can now be named. Example:
 ```scala
 type Person = (name: String, age: Int)
 val Bob: Person = (name = "Bob", age = 33)
diff --git a/docs/sidebar.yml b/docs/sidebar.yml
index 74aee3dfc668..a306d8bdf274 100644
--- a/docs/sidebar.yml
+++ b/docs/sidebar.yml
@@ -72,7 +72,6 @@ subsection:
           - page: reference/other-new-features/export.md
           - page: reference/other-new-features/opaques.md
           - page: reference/other-new-features/opaques-details.md
-          - page: reference/other-new-features/named-tuples.md
           - page: reference/other-new-features/open-classes.md
           - page: reference/other-new-features/parameter-untupling.md
           - page: reference/other-new-features/parameter-untupling-spec.md
@@ -159,6 +158,7 @@ subsection:
           - page: reference/experimental/cc.md
           - page: reference/experimental/purefuns.md
           - page: reference/experimental/tupled-function.md
+          - page: reference/experimental/named-tuples.md
           - page: reference/experimental/modularity.md
           - page: reference/experimental/typeclasses.md
           - page: reference/experimental/runtimeChecked.md
diff --git a/library/src/scala/NamedTuple.scala b/library/src/scala/NamedTuple.scala
index d105cf042f37..6da7f940dc47 100644
--- a/library/src/scala/NamedTuple.scala
+++ b/library/src/scala/NamedTuple.scala
@@ -1,6 +1,8 @@
 package scala
+import annotation.experimental
 import compiletime.ops.boolean.*
 
+@experimental
 object NamedTuple:
 
   /** The type to which named tuples get mapped to. For instance,
@@ -131,6 +133,7 @@ object NamedTuple:
 end NamedTuple
 
 /** Separate from NamedTuple object so that we can match on the opaque type NamedTuple. */
+@experimental
 object NamedTupleDecomposition:
   import NamedTuple.*
   extension [N <: Tuple, V <: Tuple](x: NamedTuple[N, V])
diff --git a/library/src/scala/runtime/stdLibPatches/language.scala b/library/src/scala/runtime/stdLibPatches/language.scala
index b8d990cf56f5..547710d55293 100644
--- a/library/src/scala/runtime/stdLibPatches/language.scala
+++ b/library/src/scala/runtime/stdLibPatches/language.scala
@@ -97,7 +97,6 @@ object language:
      *  @see [[https://dotty.epfl.ch/docs/reference/experimental/named-tuples]]
      */
     @compileTimeOnly("`namedTuples` can only be used at compile time in import statements")
-    @deprecated("The experimental.namedTuples language import is no longer needed since the feature is now standard", since = "3.6")
     object namedTuples
 
     /** Experimental support for new features for better modularity, including
diff --git a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala
index 7be2ea6181ef..ab28baea994b 100644
--- a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala
+++ b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala
@@ -1988,7 +1988,8 @@ class CompletionSuite extends BaseCompletionSuite:
 
   @Test def `namedTuple completions` =
     check(
-      """|import scala.NamedTuple.*
+      """|import scala.language.experimental.namedTuples
+         |import scala.NamedTuple.*
          |
          |val person = (name = "Jamie", city = "Lausanne")
          |
@@ -1999,7 +2000,8 @@ class CompletionSuite extends BaseCompletionSuite:
 
   @Test def `Selectable with namedTuple Fields member` =
     check(
-      """|import scala.NamedTuple.*
+      """|import scala.language.experimental.namedTuples
+         |import scala.NamedTuple.*
          |
          |class NamedTupleSelectable extends Selectable {
          |  type Fields <: AnyNamedTuple
diff --git a/tests/neg/i20517.check b/tests/neg/i20517.check
index 119c34025ee0..55aeff46572b 100644
--- a/tests/neg/i20517.check
+++ b/tests/neg/i20517.check
@@ -1,7 +1,7 @@
--- [E007] Type Mismatch Error: tests/neg/i20517.scala:9:43 -------------------------------------------------------------
-9 |  def dep(foo: Foo[Any]): From[foo.type] = (elem = "") // error
-  |                                           ^^^^^^^^^^^
-  |                                           Found:    (elem : String)
-  |                                           Required: NamedTuple.From[(foo : Foo[Any])]
-  |
-  | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg/i20517.scala:10:43 ------------------------------------------------------------
+10 |  def dep(foo: Foo[Any]): From[foo.type] = (elem = "") // error
+   |                                           ^^^^^^^^^^^
+   |                                           Found:    (elem : String)
+   |                                           Required: NamedTuple.From[(foo : Foo[Any])]
+   |
+   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/i20517.scala b/tests/neg/i20517.scala
index 342a7d86ca7e..11c4432434dd 100644
--- a/tests/neg/i20517.scala
+++ b/tests/neg/i20517.scala
@@ -1,3 +1,4 @@
+import scala.language.experimental.namedTuples
 import NamedTuple.From
 
 case class Foo[+T](elem: T)
diff --git a/tests/neg/infix-named-args.check b/tests/neg/infix-named-args.check
index 0cfbbaef73a3..291c7616a57c 100644
--- a/tests/neg/infix-named-args.check
+++ b/tests/neg/infix-named-args.check
@@ -1,5 +1,5 @@
--- [E134] Type Error: tests/neg/infix-named-args.scala:2:13 ------------------------------------------------------------
-2 |  def f = 42 + (x = 1) // error // werror
+-- [E134] Type Error: tests/neg/infix-named-args.scala:4:13 ------------------------------------------------------------
+4 |  def f = 42 + (x = 1) // error // werror
   |          ^^^^
   |          None of the overloaded alternatives of method + in class Int with types
   |           (x: Double): Double
@@ -11,29 +11,29 @@
   |           (x: Byte): Int
   |           (x: String): String
   |          match arguments ((x : Int)) (a named tuple)
--- [E204] Syntax Warning: tests/neg/infix-named-args.scala:2:15 --------------------------------------------------------
-2 |  def f = 42 + (x = 1) // error // werror
+-- [E204] Syntax Warning: tests/neg/infix-named-args.scala:4:15 --------------------------------------------------------
+4 |  def f = 42 + (x = 1) // error // werror
   |               ^^^^^^^
   |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
   |This can be rewritten automatically under -rewrite -source 3.6-migration.
   |
   | longer explanation available when compiling with `-explain`
--- [E204] Syntax Warning: tests/neg/infix-named-args.scala:5:26 --------------------------------------------------------
-5 |  def g = new C() `multi` (x = 42, y = 27) // werror
+-- [E204] Syntax Warning: tests/neg/infix-named-args.scala:7:26 --------------------------------------------------------
+7 |  def g = new C() `multi` (x = 42, y = 27) // werror
   |                          ^^^^^^^^^^^^^^^^
   |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
   |This can be rewritten automatically under -rewrite -source 3.6-migration.
   |
   | longer explanation available when compiling with `-explain`
--- [E204] Syntax Warning: tests/neg/infix-named-args.scala:6:21 --------------------------------------------------------
-6 |  def h = new C() ** (x = 42, y = 27) // werror
+-- [E204] Syntax Warning: tests/neg/infix-named-args.scala:8:21 --------------------------------------------------------
+8 |  def h = new C() ** (x = 42, y = 27) // werror
   |                     ^^^^^^^^^^^^^^^^
   |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
   |This can be rewritten automatically under -rewrite -source 3.6-migration.
   |
   | longer explanation available when compiling with `-explain`
--- [E204] Syntax Warning: tests/neg/infix-named-args.scala:13:18 -------------------------------------------------------
-13 |  def f = this ** (x = 2) // werror
+-- [E204] Syntax Warning: tests/neg/infix-named-args.scala:15:18 -------------------------------------------------------
+15 |  def f = this ** (x = 2) // werror
    |                  ^^^^^^^
    |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
    |This can be rewritten automatically under -rewrite -source 3.6-migration.
diff --git a/tests/neg/infix-named-args.scala b/tests/neg/infix-named-args.scala
index d8616899540c..b0ef555cf965 100644
--- a/tests/neg/infix-named-args.scala
+++ b/tests/neg/infix-named-args.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.namedTuples
+
 class C:
   def f = 42 + (x = 1) // error // werror
   def multi(x: Int, y: Int): Int = x + y
diff --git a/tests/neg/named-tuple-selectable.scala b/tests/neg/named-tuple-selectable.scala
index c81eba1237ff..5cf7e68654ef 100644
--- a/tests/neg/named-tuple-selectable.scala
+++ b/tests/neg/named-tuple-selectable.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.namedTuples
+
 class FromFields extends Selectable:
   type Fields = (i: Int)
   def selectDynamic(key: String) =
diff --git a/tests/neg/named-tuples-2.check b/tests/neg/named-tuples-2.check
index daa1c0d69069..0a52d5f3989b 100644
--- a/tests/neg/named-tuples-2.check
+++ b/tests/neg/named-tuples-2.check
@@ -1,8 +1,8 @@
--- Error: tests/neg/named-tuples-2.scala:4:9 ---------------------------------------------------------------------------
-4 |    case (name, age) => () // error
+-- Error: tests/neg/named-tuples-2.scala:5:9 ---------------------------------------------------------------------------
+5 |    case (name, age) => () // error
   |         ^
   |         this case is unreachable since type (String, Int, Boolean) is not a subclass of class Tuple2
--- Error: tests/neg/named-tuples-2.scala:5:9 ---------------------------------------------------------------------------
-5 |    case (n, a, m, x) => () // error
+-- Error: tests/neg/named-tuples-2.scala:6:9 ---------------------------------------------------------------------------
+6 |    case (n, a, m, x) => () // error
   |         ^
   |         this case is unreachable since type (String, Int, Boolean) is not a subclass of class Tuple4
diff --git a/tests/neg/named-tuples-2.scala b/tests/neg/named-tuples-2.scala
index b3917d9ad57c..0507891e0549 100644
--- a/tests/neg/named-tuples-2.scala
+++ b/tests/neg/named-tuples-2.scala
@@ -1,3 +1,4 @@
+import language.experimental.namedTuples
 def Test =
   val person = (name = "Bob", age = 33, married = true)
   person match
diff --git a/tests/neg/named-tuples-3.check b/tests/neg/named-tuples-3.check
index 2809836b4803..2091c36191c0 100644
--- a/tests/neg/named-tuples-3.check
+++ b/tests/neg/named-tuples-3.check
@@ -1,5 +1,5 @@
--- [E007] Type Mismatch Error: tests/neg/named-tuples-3.scala:5:16 -----------------------------------------------------
-5 |val p: Person = f  // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples-3.scala:7:16 -----------------------------------------------------
+7 |val p: Person = f  // error
   |                ^
   |                Found:    NamedTuple.NamedTuple[(Int, Any), (Int, String)]
   |                Required: Person
diff --git a/tests/neg/named-tuples-3.scala b/tests/neg/named-tuples-3.scala
index 21e6ed9b3741..0f1215338b0a 100644
--- a/tests/neg/named-tuples-3.scala
+++ b/tests/neg/named-tuples-3.scala
@@ -1,3 +1,5 @@
+import language.experimental.namedTuples
+
 def f: NamedTuple.NamedTuple[(Int, Any), (Int, String)] = ???
 
 type Person = (name: Int, age: String)
diff --git a/tests/neg/named-tuples.check b/tests/neg/named-tuples.check
index 8ec958b6a75d..db3cc703722f 100644
--- a/tests/neg/named-tuples.check
+++ b/tests/neg/named-tuples.check
@@ -1,101 +1,101 @@
--- Error: tests/neg/named-tuples.scala:8:19 ----------------------------------------------------------------------------
-8 |  val illformed = (_2 = 2) // error
+-- Error: tests/neg/named-tuples.scala:9:19 ----------------------------------------------------------------------------
+9 |  val illformed = (_2 = 2) // error
   |                   ^^^^^^
   |                   _2 cannot be used as the name of a tuple element because it is a regular tuple selector
--- Error: tests/neg/named-tuples.scala:9:20 ----------------------------------------------------------------------------
-9 |  type Illformed = (_1: Int) // error
-  |                    ^^^^^^^
-  |                    _1 cannot be used as the name of a tuple element because it is a regular tuple selector
--- Error: tests/neg/named-tuples.scala:10:40 ---------------------------------------------------------------------------
-10 |  val illformed2 = (name = "", age = 0, name = true)  // error
+-- Error: tests/neg/named-tuples.scala:10:20 ---------------------------------------------------------------------------
+10 |  type Illformed = (_1: Int) // error
+   |                    ^^^^^^^
+   |                    _1 cannot be used as the name of a tuple element because it is a regular tuple selector
+-- Error: tests/neg/named-tuples.scala:11:40 ---------------------------------------------------------------------------
+11 |  val illformed2 = (name = "", age = 0, name = true)  // error
    |                                        ^^^^^^^^^^^
    |                                        Duplicate tuple element name
--- Error: tests/neg/named-tuples.scala:11:45 ---------------------------------------------------------------------------
-11 |  type Illformed2 = (name: String, age: Int, name: Boolean) // error
+-- Error: tests/neg/named-tuples.scala:12:45 ---------------------------------------------------------------------------
+12 |  type Illformed2 = (name: String, age: Int, name: Boolean) // error
    |                                             ^^^^^^^^^^^^^
    |                                             Duplicate tuple element name
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:19:20 ------------------------------------------------------
-19 |  val _: NameOnly = person // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:20:20 ------------------------------------------------------
+20 |  val _: NameOnly = person // error
    |                    ^^^^^^
    |                    Found:    (Test.person : (name : String, age : Int))
    |                    Required: Test.NameOnly
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:20:18 ------------------------------------------------------
-20 |  val _: Person = nameOnly // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:21:18 ------------------------------------------------------
+21 |  val _: Person = nameOnly // error
    |                  ^^^^^^^^
    |                  Found:    (Test.nameOnly : (name : String))
    |                  Required: Test.Person
    |
    | longer explanation available when compiling with `-explain`
--- [E172] Type Error: tests/neg/named-tuples.scala:21:41 ---------------------------------------------------------------
-21 |  val _: Person = (name = "") ++ nameOnly // error
+-- [E172] Type Error: tests/neg/named-tuples.scala:22:41 ---------------------------------------------------------------
+22 |  val _: Person = (name = "") ++ nameOnly // error
    |                                         ^
    |    Cannot prove that Tuple.Disjoint[Tuple1[("name" : String)], Tuple1[("name" : String)]] =:= (true : Boolean).
--- [E008] Not Found Error: tests/neg/named-tuples.scala:22:9 -----------------------------------------------------------
-22 |  person._1 // error
+-- [E008] Not Found Error: tests/neg/named-tuples.scala:23:9 -----------------------------------------------------------
+23 |  person._1 // error
    |  ^^^^^^^^^
    |  value _1 is not a member of (name : String, age : Int)
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:24:36 ------------------------------------------------------
-24 |  val _: (age: Int, name: String) = person // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:25:36 ------------------------------------------------------
+25 |  val _: (age: Int, name: String) = person // error
    |                                    ^^^^^^
    |                                    Found:    (Test.person : (name : String, age : Int))
    |                                    Required: (age : Int, name : String)
    |
    | longer explanation available when compiling with `-explain`
--- Error: tests/neg/named-tuples.scala:26:17 ---------------------------------------------------------------------------
-26 |  val (name = x, agee = y) = person // error
+-- Error: tests/neg/named-tuples.scala:27:17 ---------------------------------------------------------------------------
+27 |  val (name = x, agee = y) = person // error
    |                 ^^^^^^^^
    |                 No element named `agee` is defined in selector type (name : String, age : Int)
--- Error: tests/neg/named-tuples.scala:29:10 ---------------------------------------------------------------------------
-29 |    case (name = n, age = a) => () // error // error
+-- Error: tests/neg/named-tuples.scala:30:10 ---------------------------------------------------------------------------
+30 |    case (name = n, age = a) => () // error // error
    |          ^^^^^^^^
    |          No element named `name` is defined in selector type (String, Int)
--- Error: tests/neg/named-tuples.scala:29:20 ---------------------------------------------------------------------------
-29 |    case (name = n, age = a) => () // error // error
+-- Error: tests/neg/named-tuples.scala:30:20 ---------------------------------------------------------------------------
+30 |    case (name = n, age = a) => () // error // error
    |                    ^^^^^^^
    |                    No element named `age` is defined in selector type (String, Int)
--- [E172] Type Error: tests/neg/named-tuples.scala:31:27 ---------------------------------------------------------------
-31 |  val pp = person ++ (1, 2)  // error
+-- [E172] Type Error: tests/neg/named-tuples.scala:32:27 ---------------------------------------------------------------
+32 |  val pp = person ++ (1, 2)  // error
    |                           ^
    |            Cannot prove that Tuple.Disjoint[(("name" : String), ("age" : String)), Tuple] =:= (true : Boolean).
--- [E172] Type Error: tests/neg/named-tuples.scala:34:18 ---------------------------------------------------------------
-34 |  person ++ (1, 2) match // error
+-- [E172] Type Error: tests/neg/named-tuples.scala:35:18 ---------------------------------------------------------------
+35 |  person ++ (1, 2) match // error
    |                  ^
    |            Cannot prove that Tuple.Disjoint[(("name" : String), ("age" : String)), Tuple] =:= (true : Boolean).
--- Error: tests/neg/named-tuples.scala:37:17 ---------------------------------------------------------------------------
-37 |  val bad = ("", age = 10) // error
+-- Error: tests/neg/named-tuples.scala:38:17 ---------------------------------------------------------------------------
+38 |  val bad = ("", age = 10) // error
    |                 ^^^^^^^^
    |                 Illegal combination of named and unnamed tuple elements
--- Error: tests/neg/named-tuples.scala:40:20 ---------------------------------------------------------------------------
-40 |    case (name = n, age) => () // error
+-- Error: tests/neg/named-tuples.scala:41:20 ---------------------------------------------------------------------------
+41 |    case (name = n, age) => () // error
    |                    ^^^
    |                    Illegal combination of named and unnamed tuple elements
--- Error: tests/neg/named-tuples.scala:41:16 ---------------------------------------------------------------------------
-41 |    case (name, age = a) => () // error
+-- Error: tests/neg/named-tuples.scala:42:16 ---------------------------------------------------------------------------
+42 |    case (name, age = a) => () // error
    |                ^^^^^^^
    |                Illegal combination of named and unnamed tuple elements
--- Error: tests/neg/named-tuples.scala:44:10 ---------------------------------------------------------------------------
-44 |    case (age = x) => // error
+-- Error: tests/neg/named-tuples.scala:45:10 ---------------------------------------------------------------------------
+45 |    case (age = x) => // error
    |          ^^^^^^^
    |          No element named `age` is defined in selector type Tuple
--- [E172] Type Error: tests/neg/named-tuples.scala:46:27 ---------------------------------------------------------------
-46 |  val p2 = person ++ person // error
+-- [E172] Type Error: tests/neg/named-tuples.scala:47:27 ---------------------------------------------------------------
+47 |  val p2 = person ++ person // error
    |                           ^
    |Cannot prove that Tuple.Disjoint[(("name" : String), ("age" : String)), (("name" : String), ("age" : String))] =:= (true : Boolean).
--- [E172] Type Error: tests/neg/named-tuples.scala:47:43 ---------------------------------------------------------------
-47 |  val p3 = person ++ (first = 11, age = 33) // error
+-- [E172] Type Error: tests/neg/named-tuples.scala:48:43 ---------------------------------------------------------------
+48 |  val p3 = person ++ (first = 11, age = 33) // error
    |                                           ^
    |Cannot prove that Tuple.Disjoint[(("name" : String), ("age" : String)), (("first" : String), ("age" : String))] =:= (true : Boolean).
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:49:22 ------------------------------------------------------
-49 |  val p5 = person.zip((first = 11, age = 33)) // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:50:22 ------------------------------------------------------
+50 |  val p5 = person.zip((first = 11, age = 33)) // error
    |                      ^^^^^^^^^^^^^^^^^^^^^^
    |                      Found:    (first : Int, age : Int)
    |                      Required: NamedTuple.NamedTuple[(("name" : String), ("age" : String)), Tuple]
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:60:32 ------------------------------------------------------
-60 |  val typo: (name: ?, age: ?) = (name = "he", ag = 1) // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:61:32 ------------------------------------------------------
+61 |  val typo: (name: ?, age: ?) = (name = "he", ag = 1) // error
    |                                ^^^^^^^^^^^^^^^^^^^^^
    |                                Found:    (name : String, ag : Int)
    |                                Required: (name : ?, age : ?)
diff --git a/tests/neg/named-tuples.scala b/tests/neg/named-tuples.scala
index daae6e26bac2..8f78f7915206 100644
--- a/tests/neg/named-tuples.scala
+++ b/tests/neg/named-tuples.scala
@@ -1,6 +1,7 @@
 import annotation.experimental
+import language.experimental.namedTuples
 
-object Test:
+@experimental object Test:
 
   type Person = (name: String, age: Int)
   val person = (name = "Bob", age = 33): (name: String, age: Int)
diff --git a/tests/new/test.scala b/tests/new/test.scala
index dc1891f3525c..18644422ab06 100644
--- a/tests/new/test.scala
+++ b/tests/new/test.scala
@@ -1,3 +1,5 @@
+import language.experimental.namedTuples
+
 type Person = (name: String, age: Int)
 
 trait A:
diff --git a/tests/pos/fieldsOf.scala b/tests/pos/fieldsOf.scala
index 08f20a1f7e8e..2594dae2cbf7 100644
--- a/tests/pos/fieldsOf.scala
+++ b/tests/pos/fieldsOf.scala
@@ -1,3 +1,5 @@
+import language.experimental.namedTuples
+
 case class Person(name: String, age: Int)
 
 type PF = NamedTuple.From[Person]
diff --git a/tests/pos/i20377.scala b/tests/pos/i20377.scala
index a555e01867ab..661fa7adfca9 100644
--- a/tests/pos/i20377.scala
+++ b/tests/pos/i20377.scala
@@ -1,3 +1,4 @@
+import language.experimental.namedTuples
 import NamedTuple.{NamedTuple, AnyNamedTuple}
 
 // Repros for bugs or questions
diff --git a/tests/pos/i21300.scala b/tests/pos/i21300.scala
index e7c7965b0e9a..22859482ef98 100644
--- a/tests/pos/i21300.scala
+++ b/tests/pos/i21300.scala
@@ -1,15 +1,17 @@
+import scala.language.experimental.namedTuples
+
 class Test[S <: String & Singleton](name: S):
 
   type NT = NamedTuple.NamedTuple[(S, "foo"), (Int, Long)]
   def nt: NT = ???
 
   type Name = S
-
+  
   type NT2 = NamedTuple.NamedTuple[(Name, "foo"), (Int, Long)]
   def nt2: NT2 = ???
 
 def test =
   val foo = new Test("bar")
-
+  
   foo.nt.bar
   foo.nt2.bar
diff --git a/tests/pos/i21413.scala b/tests/pos/i21413.scala
index d2dc52e34630..72b5c6d59d8d 100644
--- a/tests/pos/i21413.scala
+++ b/tests/pos/i21413.scala
@@ -1,2 +1,4 @@
+import scala.language.experimental.namedTuples
+
 val x = (aaa = 1).aaa
 //val y = x.aaa
\ No newline at end of file
diff --git a/tests/pos/named-tuple-combinators.scala b/tests/pos/named-tuple-combinators.scala
index c027ba688d02..a5134b2e7d26 100644
--- a/tests/pos/named-tuple-combinators.scala
+++ b/tests/pos/named-tuple-combinators.scala
@@ -1,3 +1,4 @@
+import scala.language.experimental.namedTuples
 
 object Test:
   // original code from issue https://github.com/scala/scala3/issues/20427
diff --git a/tests/pos/named-tuple-selectable.scala b/tests/pos/named-tuple-selectable.scala
index 0e1324f70ae6..be5f0400e58c 100644
--- a/tests/pos/named-tuple-selectable.scala
+++ b/tests/pos/named-tuple-selectable.scala
@@ -1,3 +1,4 @@
+import scala.language.experimental.namedTuples
 
 class FromFields extends Selectable:
   type Fields = (xs: List[Int], poly: [T] => (x: List[T]) => Option[T])
diff --git a/tests/pos/named-tuple-selections.scala b/tests/pos/named-tuple-selections.scala
index 7b73daad2e72..c3569f21b323 100644
--- a/tests/pos/named-tuple-selections.scala
+++ b/tests/pos/named-tuple-selections.scala
@@ -1,3 +1,4 @@
+import scala.language.experimental.namedTuples
 
 object Test1:
   // original code from issue https://github.com/scala/scala3/issues/20439
diff --git a/tests/pos/named-tuple-unstable.scala b/tests/pos/named-tuple-unstable.scala
index d15bdc578a3a..6a6a36732a14 100644
--- a/tests/pos/named-tuple-unstable.scala
+++ b/tests/pos/named-tuple-unstable.scala
@@ -1,3 +1,4 @@
+import scala.language.experimental.namedTuples
 import NamedTuple.{AnyNamedTuple, NamedTuple}
 
 trait Foo extends Selectable:
diff --git a/tests/pos/named-tuple-widen.scala b/tests/pos/named-tuple-widen.scala
index cc12a5f09b16..410832e04c17 100644
--- a/tests/pos/named-tuple-widen.scala
+++ b/tests/pos/named-tuple-widen.scala
@@ -1,3 +1,4 @@
+import language.experimental.namedTuples
 
 class A
 class B
diff --git a/tests/pos/named-tuples-ops-mirror.scala b/tests/pos/named-tuples-ops-mirror.scala
index b8745cf785d5..f66eb89534fb 100644
--- a/tests/pos/named-tuples-ops-mirror.scala
+++ b/tests/pos/named-tuples-ops-mirror.scala
@@ -1,3 +1,4 @@
+import language.experimental.namedTuples
 import NamedTuple.*
 
 @FailsWith[HttpError]
diff --git a/tests/pos/named-tuples1.scala b/tests/pos/named-tuples1.scala
index 532f1df7efd4..58e3fc065e61 100644
--- a/tests/pos/named-tuples1.scala
+++ b/tests/pos/named-tuples1.scala
@@ -1,4 +1,5 @@
 import annotation.experimental
+import language.experimental.namedTuples
 
 @main def Test =
   val bob = (name = "Bob", age = 33): (name: String, age: Int)
diff --git a/tests/pos/namedtuple-src-incompat.scala b/tests/pos/namedtuple-src-incompat.scala
index 76eb5e4aa850..57451a4321b7 100644
--- a/tests/pos/namedtuple-src-incompat.scala
+++ b/tests/pos/namedtuple-src-incompat.scala
@@ -1,3 +1,4 @@
+import language.experimental.namedTuples
 var age = 22
 val x = (age = 1)
 val _: (age: Int) = x
diff --git a/tests/pos/tuple-ops.scala b/tests/pos/tuple-ops.scala
index e89c0e8e51aa..739b1ebeeb02 100644
--- a/tests/pos/tuple-ops.scala
+++ b/tests/pos/tuple-ops.scala
@@ -1,3 +1,4 @@
+import language.experimental.namedTuples
 import Tuple.*
 
 def test =
diff --git a/tests/rewrites/infix-named-args.check b/tests/rewrites/infix-named-args.check
index a50593ef18a8..5f59cf272ba1 100644
--- a/tests/rewrites/infix-named-args.check
+++ b/tests/rewrites/infix-named-args.check
@@ -1,3 +1,5 @@
+import scala.language.experimental.namedTuples
+
 class C:
   def multi(x: Int, y: Int): Int = x + y
   def **(x: Int, y: Int): Int = x + y
@@ -12,4 +14,4 @@ class D(d: Int):
   def f = this.**(x = 2)
   def g = this ** 2
   def h = this ** ((x = 2))
-  def i = this.**(x = (1 + 1))
\ No newline at end of file
+  def i = this.**(x = (1 + 1))
diff --git a/tests/rewrites/infix-named-args.scala b/tests/rewrites/infix-named-args.scala
index bcdf4a21a9d2..a954776a9104 100644
--- a/tests/rewrites/infix-named-args.scala
+++ b/tests/rewrites/infix-named-args.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.namedTuples
+
 class C:
   def multi(x: Int, y: Int): Int = x + y
   def **(x: Int, y: Int): Int = x + y
diff --git a/tests/run-tasty-inspector/stdlibExperimentalDefinitions.scala b/tests/run-tasty-inspector/stdlibExperimentalDefinitions.scala
index 7a8dcb9bd2df..65e3a730ee7e 100644
--- a/tests/run-tasty-inspector/stdlibExperimentalDefinitions.scala
+++ b/tests/run-tasty-inspector/stdlibExperimentalDefinitions.scala
@@ -77,6 +77,12 @@ val experimentalDefinitionInLibrary = Set(
   // New feature: fromNullable for explicit nulls
   "scala.Predef$.fromNullable",
 
+  // New feature: named tuples
+  "scala.NamedTuple",
+  "scala.NamedTuple$",
+  "scala.NamedTupleDecomposition",
+  "scala.NamedTupleDecomposition$",
+
   // New feature: modularity
   "scala.Precise",
   "scala.annotation.internal.WitnessNames",
diff --git a/tests/run/named-patmatch.scala b/tests/run/named-patmatch.scala
index 6fe1934f008e..e62497e4aa8f 100644
--- a/tests/run/named-patmatch.scala
+++ b/tests/run/named-patmatch.scala
@@ -1,4 +1,5 @@
 import annotation.experimental
+import language.experimental.namedTuples
 
 @main def Test =
   locally:
diff --git a/tests/run/named-patterns.scala b/tests/run/named-patterns.scala
index e92bbf751c22..7c24dc8d683a 100644
--- a/tests/run/named-patterns.scala
+++ b/tests/run/named-patterns.scala
@@ -1,3 +1,4 @@
+import language.experimental.namedTuples
 
 object Test1:
   class Person(val name: String, val age: Int)
diff --git a/tests/run/named-tuple-ops.scala b/tests/run/named-tuple-ops.scala
index 8c6db6f2fa1c..076ab5028c6c 100644
--- a/tests/run/named-tuple-ops.scala
+++ b/tests/run/named-tuple-ops.scala
@@ -1,4 +1,5 @@
 //> using options -source future
+import language.experimental.namedTuples
 import scala.compiletime.asMatchable
 
 type City = (name: String, zip: Int, pop: Int)
diff --git a/tests/run/named-tuples-xxl.scala b/tests/run/named-tuples-xxl.scala
index 8c831fb1d223..3a0a1e5e1294 100644
--- a/tests/run/named-tuples-xxl.scala
+++ b/tests/run/named-tuples-xxl.scala
@@ -1,3 +1,4 @@
+import language.experimental.namedTuples
 import NamedTuple.toTuple
 
 type Person = (
diff --git a/tests/run/named-tuples.scala b/tests/run/named-tuples.scala
index c99393a403b3..406c6195cf0f 100644
--- a/tests/run/named-tuples.scala
+++ b/tests/run/named-tuples.scala
@@ -1,3 +1,4 @@
+import language.experimental.namedTuples
 import NamedTuple.*
 
 type Person = (name: String, age: Int)
diff --git a/tests/run/tyql.scala b/tests/run/tyql.scala
index ee3fd1138265..8fe253b559ac 100644
--- a/tests/run/tyql.scala
+++ b/tests/run/tyql.scala
@@ -1,3 +1,4 @@
+import language.experimental.namedTuples
 import NamedTuple.{NamedTuple, AnyNamedTuple}
 
 /* This is a demonstrator that shows how to map regular for expressions to
diff --git a/tests/warn/21681.check b/tests/warn/21681.check
index e86ce4e36134..6ca2c3816b01 100644
--- a/tests/warn/21681.check
+++ b/tests/warn/21681.check
@@ -1,5 +1,5 @@
--- [E203] Syntax Migration Warning: tests/warn/21681.scala:3:2 ---------------------------------------------------------
-3 |  (age = 29) // warn
+-- [E203] Syntax Migration Warning: tests/warn/21681.scala:5:2 ---------------------------------------------------------
+5 |  (age = 29) // warn
   |  ^^^^^^^^^^
   |  Ambiguous syntax: this is interpreted as a named tuple with one element,
   |  not as an assignment.
diff --git a/tests/warn/21681.scala b/tests/warn/21681.scala
index 76a19c96e1cb..67f45571ecf6 100644
--- a/tests/warn/21681.scala
+++ b/tests/warn/21681.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.namedTuples
+
 def main() =
   var age: Int = 28
   (age = 29) // warn
diff --git a/tests/warn/21681b.check b/tests/warn/21681b.check
index 32760e00ebb6..c77c1438d9a6 100644
--- a/tests/warn/21681b.check
+++ b/tests/warn/21681b.check
@@ -1,5 +1,5 @@
--- [E203] Syntax Migration Warning: tests/warn/21681b.scala:3:2 --------------------------------------------------------
-3 |  (age = 29) // warn
+-- [E203] Syntax Migration Warning: tests/warn/21681b.scala:5:2 --------------------------------------------------------
+5 |  (age = 29) // warn
   |  ^^^^^^^^^^
   |  Ambiguous syntax: this is interpreted as a named tuple with one element,
   |  not as an assignment.
diff --git a/tests/warn/21681b.scala b/tests/warn/21681b.scala
index 710d69b0dd23..44d04fc98aad 100644
--- a/tests/warn/21681b.scala
+++ b/tests/warn/21681b.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.namedTuples
+
 object Test:
   var age: Int = 28
   (age = 29) // warn
diff --git a/tests/warn/21681c.check b/tests/warn/21681c.check
index 11c427f87cfe..00c74ddba5bc 100644
--- a/tests/warn/21681c.check
+++ b/tests/warn/21681c.check
@@ -1,5 +1,5 @@
--- [E203] Syntax Migration Warning: tests/warn/21681c.scala:5:2 --------------------------------------------------------
-5 |  (age = 29) // warn
+-- [E203] Syntax Migration Warning: tests/warn/21681c.scala:7:2 --------------------------------------------------------
+7 |  (age = 29) // warn
   |  ^^^^^^^^^^
   |  Ambiguous syntax: this is interpreted as a named tuple with one element,
   |  not as an assignment.
diff --git a/tests/warn/21681c.scala b/tests/warn/21681c.scala
index 5e2eae11708c..a0c361382a54 100644
--- a/tests/warn/21681c.scala
+++ b/tests/warn/21681c.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.namedTuples
+
 object Test:
   def age: Int = ???
   def age_=(x: Int): Unit = ()
diff --git a/tests/warn/21770.check b/tests/warn/21770.check
index 0899f11d6ca5..10a1c287599c 100644
--- a/tests/warn/21770.check
+++ b/tests/warn/21770.check
@@ -1,5 +1,5 @@
--- [E203] Syntax Migration Warning: tests/warn/21770.scala:5:9 ---------------------------------------------------------
-5 |  f(i => (cache = Some(i))) // warn
+-- [E203] Syntax Migration Warning: tests/warn/21770.scala:7:9 ---------------------------------------------------------
+7 |  f(i => (cache = Some(i))) // warn
   |         ^^^^^^^^^^^^^^^^^
   |         Ambiguous syntax: this is interpreted as a named tuple with one element,
   |         not as an assignment.
diff --git a/tests/warn/21770.scala b/tests/warn/21770.scala
index 9696a31d6ba8..8ee5b52e7b3f 100644
--- a/tests/warn/21770.scala
+++ b/tests/warn/21770.scala
@@ -1,5 +1,7 @@
+import scala.language.experimental.namedTuples
+
 def f(g: Int  => Unit) = g(0)
 
-def test = 
+def test =
   var cache: Option[Int] = None
   f(i => (cache = Some(i))) // warn
diff --git a/tests/warn/infix-named-args-migration.scala b/tests/warn/infix-named-args-migration.scala
index df4bfb50271c..361004f08f13 100644
--- a/tests/warn/infix-named-args-migration.scala
+++ b/tests/warn/infix-named-args-migration.scala
@@ -1,4 +1,6 @@
 //> using options -source:3.6-migration
+import scala.language.experimental.namedTuples
+
 class C:
   def f = 42 + (x = 1) // warn // interpreted as 42.+(x = 1) under migration, x is a valid synthetic parameter name
   def multi(x: Int, y: Int): Int = x + y

From 861beeef093501717bf322a5b442199188664daa Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Wed, 27 Nov 2024 22:36:20 +0100
Subject: [PATCH 239/306] Add migration rewrite for deprecated assignment
 syntax

---
 .../tools/dotc/config/MigrationVersion.scala  |  2 +-
 .../dotty/tools/dotc/parsing/Parsers.scala    |  4 ++--
 .../tools/dotc/reporting/ErrorMessageID.scala |  4 ++--
 .../dotty/tools/dotc/reporting/messages.scala | 18 ++++++++---------
 .../src/dotty/tools/dotc/typer/Typer.scala    |  6 +++---
 tests/neg/infix-named-args.check              | 20 ++++++++-----------
 tests/warn/21681.check                        |  2 +-
 tests/warn/21681b.check                       |  2 +-
 tests/warn/21681c.check                       |  2 +-
 tests/warn/21770.check                        |  2 +-
 10 files changed, 28 insertions(+), 34 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/config/MigrationVersion.scala b/compiler/src/dotty/tools/dotc/config/MigrationVersion.scala
index 247e3f62a98d..1d99caa789d3 100644
--- a/compiler/src/dotty/tools/dotc/config/MigrationVersion.scala
+++ b/compiler/src/dotty/tools/dotc/config/MigrationVersion.scala
@@ -26,7 +26,7 @@ enum MigrationVersion(val warnFrom: SourceVersion, val errorFrom: SourceVersion)
   case WithOperator extends MigrationVersion(`3.4`, future)
   case FunctionUnderscore extends MigrationVersion(`3.4`, future)
   case NonNamedArgumentInJavaAnnotation extends MigrationVersion(`3.6`, `3.6`)
-  case AmbiguousNamedTupleInfixApply extends MigrationVersion(`3.6`, never)
+  case AmbiguousNamedTupleSyntax extends MigrationVersion(`3.6`, future)
   case ImportWildcard extends MigrationVersion(future, future)
   case ImportRename extends MigrationVersion(future, future)
   case ParameterEnclosedByParenthesis extends MigrationVersion(future, future)
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 3ea4131d5d78..220053e277a5 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1149,8 +1149,8 @@ object Parsers {
       if isType then infixOp
       else infixOp.right match
         case Tuple(args) if args.exists(_.isInstanceOf[NamedArg]) && !isNamedTupleOperator =>
-          report.errorOrMigrationWarning(AmbiguousNamedTupleInfixApply(), infixOp.right.srcPos, MigrationVersion.AmbiguousNamedTupleInfixApply)
-          if MigrationVersion.AmbiguousNamedTupleInfixApply.needsPatch then
+          report.errorOrMigrationWarning(DeprecatedInfixNamedArgumentSyntax(), infixOp.right.srcPos, MigrationVersion.AmbiguousNamedTupleSyntax)
+          if MigrationVersion.AmbiguousNamedTupleSyntax.needsPatch then
             val asApply = cpy.Apply(infixOp)(Select(opInfo.operand, opInfo.operator.name), args)
             patch(source, infixOp.span, asApply.show(using ctx.withoutColors))
             asApply // allow to use pre-3.6 syntax in migration mode
diff --git a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
index 35c170858bbf..2c3774b59a9a 100644
--- a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
@@ -216,8 +216,8 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case FinalLocalDefID // errorNumber: 200
   case NonNamedArgumentInJavaAnnotationID // errorNumber: 201
   case QuotedTypeMissingID // errorNumber: 202
-  case AmbiguousNamedTupleAssignmentID // errorNumber: 203
-  case AmbiguousNamedTupleInfixApplyID // errorNumber: 204
+  case DeprecatedAssignmentSyntaxID // errorNumber: 203
+  case DeprecatedInfixNamedArgumentSyntaxID // errorNumber: 204
 
   def errorNumber = ordinal - 1
 
diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index f94a4b58d6fb..2e74c5816c5e 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -3344,21 +3344,19 @@ final class QuotedTypeMissing(tpe: Type)(using Context) extends StagingMessage(Q
 
 end QuotedTypeMissing
 
-final class AmbiguousNamedTupleAssignment(key: Name, value: untpd.Tree)(using Context) extends SyntaxMsg(AmbiguousNamedTupleAssignmentID):
+final class DeprecatedAssignmentSyntax(key: Name, value: untpd.Tree)(using Context) extends SyntaxMsg(DeprecatedAssignmentSyntaxID):
   override protected def msg(using Context): String =
-    i"""Ambiguous syntax: this is interpreted as a named tuple with one element,
+    i"""Deprecated syntax: in the future it would be interpreted as a named tuple with one element,
       |not as an assignment.
       |
       |To assign a value, use curly braces: `{${key} = ${value}}`."""
-  
+
   override protected def explain(using Context): String = ""
 
-class AmbiguousNamedTupleInfixApply()(using Context) extends SyntaxMsg(AmbiguousNamedTupleInfixApplyID):
+class DeprecatedInfixNamedArgumentSyntax()(using Context) extends SyntaxMsg(DeprecatedInfixNamedArgumentSyntaxID):
   def msg(using Context) =
-    "Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list."
-    + Message.rewriteNotice("This", version = SourceVersion.`3.6-migration`)
+    i"""Deprecated syntax: infix named arguments lists are deprecated; in the future it would be interpreted as a single name tuple argument.
+       |To avoid this warning, either remove the argument names or use dotted selection."""
+        + Message.rewriteNotice("This", version = SourceVersion.`3.6-migration`)
 
-  def explain(using Context) =
-    i"""Starting with Scala 3.6 infix named arguments are interpretted as Named Tuple.
-        |
-        |To avoid this warning, either remove the argument names or use dotted selection."""
+  def explain(using Context) = ""
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 57a027653241..d74a69f2a114 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -3404,7 +3404,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   /** Translate tuples of all arities */
   def typedTuple(tree: untpd.Tuple, pt: Type)(using Context): Tree =
     val tree1 = desugar.tuple(tree, pt)
-    checkAmbiguousNamedTupleAssignment(tree)
+    checkDeprecatedAssignmentSyntax(tree)
     if tree1 ne tree then typed(tree1, pt)
     else
       val arity = tree.trees.length
@@ -3433,7 +3433,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
  /** Checks if `tree` is a named tuple with one element that could be
   *  interpreted as an assignment, such as `(x = 1)`. If so, issues a warning.
   */
-  def checkAmbiguousNamedTupleAssignment(tree: untpd.Tuple)(using Context): Unit =
+  def checkDeprecatedAssignmentSyntax(tree: untpd.Tuple)(using Context): Unit =
     tree.trees match
       case List(NamedArg(name, value)) =>
         val tmpCtx = ctx.fresh.setNewTyperState()
@@ -3441,7 +3441,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         if !tmpCtx.reporter.hasErrors then
           // If there are no errors typing the above, then the named tuple is
           // ambiguous and we issue a warning.
-          report.migrationWarning(AmbiguousNamedTupleAssignment(name, value), tree.srcPos)
+          report.migrationWarning(DeprecatedAssignmentSyntax(name, value), tree.srcPos)
       case _ => ()
 
   /** Retrieve symbol attached to given tree */
diff --git a/tests/neg/infix-named-args.check b/tests/neg/infix-named-args.check
index 291c7616a57c..d960892a9624 100644
--- a/tests/neg/infix-named-args.check
+++ b/tests/neg/infix-named-args.check
@@ -14,28 +14,24 @@
 -- [E204] Syntax Warning: tests/neg/infix-named-args.scala:4:15 --------------------------------------------------------
 4 |  def f = 42 + (x = 1) // error // werror
   |               ^^^^^^^
-  |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
+  |Deprecated syntax: infix named arguments lists are deprecated; in the future it would be interpreted as a single name tuple argument.
+  |To avoid this warning, either remove the argument names or use dotted selection.
   |This can be rewritten automatically under -rewrite -source 3.6-migration.
-  |
-  | longer explanation available when compiling with `-explain`
 -- [E204] Syntax Warning: tests/neg/infix-named-args.scala:7:26 --------------------------------------------------------
 7 |  def g = new C() `multi` (x = 42, y = 27) // werror
   |                          ^^^^^^^^^^^^^^^^
-  |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
+  |Deprecated syntax: infix named arguments lists are deprecated; in the future it would be interpreted as a single name tuple argument.
+  |To avoid this warning, either remove the argument names or use dotted selection.
   |This can be rewritten automatically under -rewrite -source 3.6-migration.
-  |
-  | longer explanation available when compiling with `-explain`
 -- [E204] Syntax Warning: tests/neg/infix-named-args.scala:8:21 --------------------------------------------------------
 8 |  def h = new C() ** (x = 42, y = 27) // werror
   |                     ^^^^^^^^^^^^^^^^
-  |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
+  |Deprecated syntax: infix named arguments lists are deprecated; in the future it would be interpreted as a single name tuple argument.
+  |To avoid this warning, either remove the argument names or use dotted selection.
   |This can be rewritten automatically under -rewrite -source 3.6-migration.
-  |
-  | longer explanation available when compiling with `-explain`
 -- [E204] Syntax Warning: tests/neg/infix-named-args.scala:15:18 -------------------------------------------------------
 15 |  def f = this ** (x = 2) // werror
    |                  ^^^^^^^
-   |Ambigious syntax: this infix call argument list is interpreted as single named tuple argument, not as an named arguments list.
+   |Deprecated syntax: infix named arguments lists are deprecated; in the future it would be interpreted as a single name tuple argument.
+   |To avoid this warning, either remove the argument names or use dotted selection.
    |This can be rewritten automatically under -rewrite -source 3.6-migration.
-   |
-   | longer explanation available when compiling with `-explain`
diff --git a/tests/warn/21681.check b/tests/warn/21681.check
index 6ca2c3816b01..5156a600d609 100644
--- a/tests/warn/21681.check
+++ b/tests/warn/21681.check
@@ -1,7 +1,7 @@
 -- [E203] Syntax Migration Warning: tests/warn/21681.scala:5:2 ---------------------------------------------------------
 5 |  (age = 29) // warn
   |  ^^^^^^^^^^
-  |  Ambiguous syntax: this is interpreted as a named tuple with one element,
+  |  Deprecated syntax: in the future it would be interpreted as a named tuple with one element,
   |  not as an assignment.
   |
   |  To assign a value, use curly braces: `{age = 29}`.
diff --git a/tests/warn/21681b.check b/tests/warn/21681b.check
index c77c1438d9a6..dd28df3168ed 100644
--- a/tests/warn/21681b.check
+++ b/tests/warn/21681b.check
@@ -1,7 +1,7 @@
 -- [E203] Syntax Migration Warning: tests/warn/21681b.scala:5:2 --------------------------------------------------------
 5 |  (age = 29) // warn
   |  ^^^^^^^^^^
-  |  Ambiguous syntax: this is interpreted as a named tuple with one element,
+  |  Deprecated syntax: in the future it would be interpreted as a named tuple with one element,
   |  not as an assignment.
   |
   |  To assign a value, use curly braces: `{age = 29}`.
diff --git a/tests/warn/21681c.check b/tests/warn/21681c.check
index 00c74ddba5bc..bfb62618cbb9 100644
--- a/tests/warn/21681c.check
+++ b/tests/warn/21681c.check
@@ -1,7 +1,7 @@
 -- [E203] Syntax Migration Warning: tests/warn/21681c.scala:7:2 --------------------------------------------------------
 7 |  (age = 29) // warn
   |  ^^^^^^^^^^
-  |  Ambiguous syntax: this is interpreted as a named tuple with one element,
+  |  Deprecated syntax: in the future it would be interpreted as a named tuple with one element,
   |  not as an assignment.
   |
   |  To assign a value, use curly braces: `{age = 29}`.
diff --git a/tests/warn/21770.check b/tests/warn/21770.check
index 10a1c287599c..6c978a6078a2 100644
--- a/tests/warn/21770.check
+++ b/tests/warn/21770.check
@@ -1,7 +1,7 @@
 -- [E203] Syntax Migration Warning: tests/warn/21770.scala:7:9 ---------------------------------------------------------
 7 |  f(i => (cache = Some(i))) // warn
   |         ^^^^^^^^^^^^^^^^^
-  |         Ambiguous syntax: this is interpreted as a named tuple with one element,
+  |         Deprecated syntax: in the future it would be interpreted as a named tuple with one element,
   |         not as an assignment.
   |
   |         To assign a value, use curly braces: `{cache = Some(i)}`.

From 24c3e7f601c6ba74c541f1603251253bfde45ab3 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Wed, 27 Nov 2024 23:54:11 +0100
Subject: [PATCH 240/306] Add migration rewrite deprecated assignment syntax

---
 .../dotty/tools/dotc/reporting/messages.scala |  1 +
 .../src/dotty/tools/dotc/typer/Typer.scala    |  3 +++
 .../dotty/tools/dotc/CompilationTests.scala   |  1 +
 .../ambigious-named-tuple-assignment.check    | 19 +++++++++++++++++++
 .../ambigious-named-tuple-assignment.scala    | 19 +++++++++++++++++++
 tests/warn/21681.check                        |  1 +
 tests/warn/21681b.check                       |  1 +
 tests/warn/21681c.check                       |  1 +
 tests/warn/21770.check                        |  1 +
 9 files changed, 47 insertions(+)
 create mode 100644 tests/rewrites/ambigious-named-tuple-assignment.check
 create mode 100644 tests/rewrites/ambigious-named-tuple-assignment.scala

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index 2e74c5816c5e..b396aa62f599 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -3350,6 +3350,7 @@ final class DeprecatedAssignmentSyntax(key: Name, value: untpd.Tree)(using Conte
       |not as an assignment.
       |
       |To assign a value, use curly braces: `{${key} = ${value}}`."""
+      + Message.rewriteNotice("This", version = SourceVersion.`3.6-migration`)
 
   override protected def explain(using Context): String = ""
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index d74a69f2a114..f5318759bac2 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -3442,6 +3442,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           // If there are no errors typing the above, then the named tuple is
           // ambiguous and we issue a warning.
           report.migrationWarning(DeprecatedAssignmentSyntax(name, value), tree.srcPos)
+          if MigrationVersion.AmbiguousNamedTupleSyntax.needsPatch then
+            patch(tree.source, Span(tree.span.start, tree.span.start + 1), "{")
+            patch(tree.source, Span(tree.span.end - 1, tree.span.end), "}")
       case _ => ()
 
   /** Retrieve symbol attached to given tree */
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index 3bd3b5138fad..9f72db6fc390 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -80,6 +80,7 @@ class CompilationTests {
       compileDir("tests/rewrites/annotation-named-pararamters", defaultOptions.and("-rewrite", "-source:3.6-migration")),
       compileFile("tests/rewrites/i21418.scala", unindentOptions.and("-rewrite", "-source:3.5-migration")),
       compileFile("tests/rewrites/infix-named-args.scala", defaultOptions.and("-rewrite", "-source:3.6-migration")),
+      compileFile("tests/rewrites/ambigious-named-tuple-assignment.scala", defaultOptions.and("-rewrite", "-source:3.6-migration")),
     ).checkRewrites()
   }
 
diff --git a/tests/rewrites/ambigious-named-tuple-assignment.check b/tests/rewrites/ambigious-named-tuple-assignment.check
new file mode 100644
index 000000000000..00e6cc4112f1
--- /dev/null
+++ b/tests/rewrites/ambigious-named-tuple-assignment.check
@@ -0,0 +1,19 @@
+import scala.language.experimental.namedTuples
+
+object i21770:
+  def f(g: Int  => Unit) = g(0)
+  var cache: Option[Int] = None
+  f(i => {cache = Some(i)})
+  
+object i21861:
+  var age: Int = 28
+  {
+    age = 29
+  }
+  
+  
+object i21861c:
+  def age: Int = ???
+  def age_=(x: Int): Unit = ()
+  age = 29
+  { age = 29 }
diff --git a/tests/rewrites/ambigious-named-tuple-assignment.scala b/tests/rewrites/ambigious-named-tuple-assignment.scala
new file mode 100644
index 000000000000..e9685b7b58cf
--- /dev/null
+++ b/tests/rewrites/ambigious-named-tuple-assignment.scala
@@ -0,0 +1,19 @@
+import scala.language.experimental.namedTuples
+
+object i21770:
+  def f(g: Int  => Unit) = g(0)
+  var cache: Option[Int] = None
+  f(i => (cache = Some(i)))
+  
+object i21861:
+  var age: Int = 28
+  (
+    age = 29
+  )
+  
+  
+object i21861c:
+  def age: Int = ???
+  def age_=(x: Int): Unit = ()
+  age = 29
+  ( age = 29 )
diff --git a/tests/warn/21681.check b/tests/warn/21681.check
index 5156a600d609..adf3586e6e0b 100644
--- a/tests/warn/21681.check
+++ b/tests/warn/21681.check
@@ -5,3 +5,4 @@
   |  not as an assignment.
   |
   |  To assign a value, use curly braces: `{age = 29}`.
+  |  This can be rewritten automatically under -rewrite -source 3.6-migration.
diff --git a/tests/warn/21681b.check b/tests/warn/21681b.check
index dd28df3168ed..09c007f351b4 100644
--- a/tests/warn/21681b.check
+++ b/tests/warn/21681b.check
@@ -5,3 +5,4 @@
   |  not as an assignment.
   |
   |  To assign a value, use curly braces: `{age = 29}`.
+  |  This can be rewritten automatically under -rewrite -source 3.6-migration.
diff --git a/tests/warn/21681c.check b/tests/warn/21681c.check
index bfb62618cbb9..20273f723384 100644
--- a/tests/warn/21681c.check
+++ b/tests/warn/21681c.check
@@ -5,3 +5,4 @@
   |  not as an assignment.
   |
   |  To assign a value, use curly braces: `{age = 29}`.
+  |  This can be rewritten automatically under -rewrite -source 3.6-migration.
diff --git a/tests/warn/21770.check b/tests/warn/21770.check
index 6c978a6078a2..7853d77a423c 100644
--- a/tests/warn/21770.check
+++ b/tests/warn/21770.check
@@ -5,3 +5,4 @@
   |         not as an assignment.
   |
   |         To assign a value, use curly braces: `{cache = Some(i)}`.
+  |         This can be rewritten automatically under -rewrite -source 3.6-migration.

From 688ed4f168d2bd40acf478f637d27f6e03c1a7d2 Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Wed, 27 Nov 2024 23:01:26 +0000
Subject: [PATCH 241/306] Do not lift annotation arguments (bis)

---
 .../dotty/tools/dotc/typer/Applications.scala |  2 ++
 .../dependent-annot-default-args.check        | 23 +++++++++++++++++++
 .../dependent-annot-default-args.scala        | 10 ++++++++
 3 files changed, 35 insertions(+)

diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index 41e48f7595dc..ff6c71f57355 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -963,6 +963,8 @@ trait Applications extends Compatibility {
                 case (arg: NamedArg, _) => arg
                 case (arg, name)        => NamedArg(name, arg)
               }
+          else if isAnnotConstr(methRef.symbol) then
+            typedArgs
           else if !sameSeq(args, orderedArgs) && !typedArgs.forall(isSafeArg) then
             // need to lift arguments to maintain evaluation order in the
             // presence of argument reorderings.
diff --git a/tests/printing/dependent-annot-default-args.check b/tests/printing/dependent-annot-default-args.check
index 44c1fe31e2d1..f457d5d62edb 100644
--- a/tests/printing/dependent-annot-default-args.check
+++ b/tests/printing/dependent-annot-default-args.check
@@ -8,16 +8,39 @@ package <empty> {
   final module class annot() extends AnyRef() { this: annot.type =>
     def $lessinit$greater$default$2: Any @uncheckedVariance = 42
   }
+  class annot2(x: Any, y: Array[Any]) extends annotation.Annotation() {
+    private[this] val x: Any
+    private[this] val y: Array[Any]
+  }
+  final lazy module val annot2: annot2 = new annot2()
+  final module class annot2() extends AnyRef() { this: annot2.type =>
+    def $lessinit$greater$default$1: Any @uncheckedVariance = -1
+    def $lessinit$greater$default$2: Array[Any] @uncheckedVariance =
+      Array.apply[Any](["Hello" : Any]*)(scala.reflect.ClassTag.Any)
+  }
   final lazy module val dependent-annot-default-args$package:
     dependent-annot-default-args$package =
     new dependent-annot-default-args$package()
   final module class dependent-annot-default-args$package() extends Object() {
     this: dependent-annot-default-args$package.type =>
     def f(x: Int): Int @annot(x) = x
+    def f2(x: Int):
+      Int @annot2(
+        y = Array.apply[Any](["Hello",x : Any]*)(scala.reflect.ClassTag.Any))
+     = x
     def test: Unit =
       {
         val y: Int = ???
         val z: Int @annot(y) = f(y)
+        val z2:
+          Int @annot2(
+            y = Array.apply[Any](["Hello",y : Any]*)(scala.reflect.ClassTag.Any)
+            )
+         = f2(y)
+        @annot(44) val z3: Int = 45
+        @annot2(
+          y = Array.apply[Any](["Hello",y : Any]*)(scala.reflect.ClassTag.Any))
+          val z4: Int = 45
         ()
       }
   }
diff --git a/tests/printing/dependent-annot-default-args.scala b/tests/printing/dependent-annot-default-args.scala
index 7ddce711fedc..11fc9ef52cc9 100644
--- a/tests/printing/dependent-annot-default-args.scala
+++ b/tests/printing/dependent-annot-default-args.scala
@@ -1,5 +1,15 @@
 class annot(x: Any, y: Any = 42) extends annotation.Annotation
+class annot2(x: Any = -1, y: Array[Any] = Array("Hello")) extends annotation.Annotation
+
 def f(x: Int): Int @annot(x) = x
+def f2(x: Int): Int @annot2(y = Array("Hello", x)) = x
+
 def test =
   val y: Int = ???
+
   val z = f(y)
+  val z2 = f2(y)
+
+  @annot(44) val z3 = 45
+  @annot2(y = Array("Hello", y)) val z4 = 45
+

From 08d592fd34f60409be52d3b3b929e18928391b45 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Thu, 31 Oct 2024 17:54:29 +0000
Subject: [PATCH 242/306] Resolve name when named imp is behind wild imps

When a named import (such as `import bug.util.List`) is defined before
two clashing wildcard imports (`import bug.util.*; import java.util.*`)
the name "List" should resolve to it, rather than a resolution error
being emitted.

This was due to the fact that `findRefRecur` didn't return the
precedence at which it found that import, `checkImportAlternatives` used
the `prevPrec` to `checkNewOrShadowed`.  Now we check against the entire
`foundResult`, allowing an early named import to be picked over later
wildcard imports.
---
 .../src/dotty/tools/dotc/typer/Typer.scala    | 81 ++++++++++---------
 tests/pos/i18529/JCode1.java                  |  9 +++
 tests/pos/i18529/JCode2.java                  |  9 +++
 tests/pos/i18529/List.java                    |  3 +
 tests/pos/i18529/SCode1.scala                 |  9 +++
 tests/pos/i18529/SCode2.scala                 |  9 +++
 tests/pos/i18529/Test.scala                   |  1 +
 7 files changed, 82 insertions(+), 39 deletions(-)
 create mode 100644 tests/pos/i18529/JCode1.java
 create mode 100644 tests/pos/i18529/JCode2.java
 create mode 100644 tests/pos/i18529/List.java
 create mode 100644 tests/pos/i18529/SCode1.scala
 create mode 100644 tests/pos/i18529/SCode2.scala
 create mode 100644 tests/pos/i18529/Test.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 13f7b4eb1726..c133d70ff9c7 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -241,38 +241,40 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         !owner.isEmptyPackage || ctx.owner.enclosingPackageClass.isEmptyPackage
       }
 
+    import BindingPrec.*
+    type Result = (Type, BindingPrec)
+    val NoResult = (NoType, NothingBound)
+
     /** 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 prevResult  A type that was found in a more deeply nested scope,
+     *                     and its precedence, or NoResult 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.*
+    def findRefRecur(prevResult: Result, prevCtx: Context)(using Context): Result = {
+      val (previous, prevPrec) = prevResult
 
       /** 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 newResult The newly found type and 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 =
+      def checkNewOrShadowed(newResult: Result, scala2pkg: Boolean = false)(using Context): Result =
+        val (found, newPrec) = newResult
         if !previous.exists || TypeComparer.isSameRef(previous, found) then
-           found
+           newResult
         else if (prevCtx.scope eq ctx.scope) && newPrec.beats(prevPrec) then
           // special cases: definitions beat imports, and named imports beat
           // wildcard imports, provided both are in contexts with same scope
-          found
+          newResult
         else
           if !scala2pkg && !previous.isError && !found.isError then
             fail(AmbiguousReference(name, newPrec, prevPrec, prevCtx,
               isExtension = previous.termSymbol.is(ExtensionMethod) && found.termSymbol.is(ExtensionMethod)))
-          previous
+          prevResult
 
       /** Assemble and check alternatives to an imported reference. This implies:
        *   - If we expand an extension method (i.e. altImports != null),
@@ -285,12 +287,13 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
        *     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.
-       *  @param previous   the previously found reference (which is an import)
-       *  @param prevPrec   the precedence of the reference (either NamedImport or WildImport)
+       *  @param prevResult the previously found reference (which is an import), and
+       *                    the precedence of the reference (either NamedImport or WildImport)
        *  @param prevCtx    the context in which the reference was found
        *  @param using_Context the outer context of `precCtx`
        */
-      def checkImportAlternatives(previous: Type, prevPrec: BindingPrec, prevCtx: Context)(using Context): Type =
+      def checkImportAlternatives(prevResult: Result, prevCtx: Context)(using Context): Result =
+        val (previous, prevPrec) = prevResult
 
         def addAltImport(altImp: TermRef) =
           if !TypeComparer.isSameRef(previous, altImp)
@@ -305,20 +308,20 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
               if prevPrec == WildImport then
                 // Discard all previously found references and continue with `altImp`
                 altImports.clear()
-                checkImportAlternatives(altImp, NamedImport, ctx)(using ctx.outer)
+                checkImportAlternatives((altImp, NamedImport), ctx)(using ctx.outer)
               else
                 addAltImport(altImp)
-                checkImportAlternatives(previous, prevPrec, prevCtx)(using ctx.outer)
+                checkImportAlternatives(prevResult, prevCtx)(using ctx.outer)
             case _ =>
               if prevPrec == WildImport then
                 wildImportRef(curImport) match
                   case altImp: TermRef => addAltImport(altImp)
                   case _ =>
-              checkImportAlternatives(previous, prevPrec, prevCtx)(using ctx.outer)
+              checkImportAlternatives(prevResult, prevCtx)(using ctx.outer)
         else
-          val found = findRefRecur(previous, prevPrec, prevCtx)
-          if found eq previous then checkNewOrShadowed(found, prevPrec)(using prevCtx)
-          else found
+          val foundResult = findRefRecur(prevResult, prevCtx)
+          if foundResult._1 eq previous then checkNewOrShadowed(foundResult)(using prevCtx)
+          else foundResult
       end checkImportAlternatives
 
       def selection(imp: ImportInfo, name: Name, checkBounds: Boolean): Type =
@@ -408,10 +411,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         !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
+      @tailrec def loop(lastCtx: Context)(using Context): Result =
+        if (ctx.scope eq EmptyScope) prevResult
         else {
-          var result: Type = NoType
+          var result: Result = NoResult
           val curOwner = ctx.owner
 
           /** Is curOwner a package object that should be skipped?
@@ -510,7 +513,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                   effectiveOwner.thisType.select(name, defDenot).makePackageObjPrefixExplicit
                 }
               if !curOwner.is(Package) || isDefinedInCurrentUnit(defDenot) then
-                result = checkNewOrShadowed(found, Definition) // no need to go further out, we found highest prec entry
+                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 =>
@@ -518,29 +521,28 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                   case _ =>
               else
                 if migrateTo3 && !foundUnderScala2.exists then
-                  foundUnderScala2 = checkNewOrShadowed(found, Definition, scala2pkg = true)
+                  foundUnderScala2 = checkNewOrShadowed((found, Definition), scala2pkg = true)._1
                 if (defDenot.symbol.is(Package))
-                  result = checkNewOrShadowed(previous orElse found, PackageClause)
+                  result = checkNewOrShadowed((previous orElse found, PackageClause))
                 else if (prevPrec.ordinal < PackageClause.ordinal)
-                  result = findRefRecur(found, PackageClause, ctx)(using ctx.outer)
+                  result = findRefRecur((found, PackageClause), ctx)(using ctx.outer)
             }
 
-          if result.exists then result
+          if result._1.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)
+              prevResult // no more conflicts possible in this case
+            else if (isPossibleImport(NamedImport) && curImport != null && (curImport ne outer.importInfo)) {
+              def updateUnimported() = if curImport.unimported ne NoSymbol then unimported += curImport.unimported
+              val namedImp = namedImportRef(curImport)
               if (namedImp.exists)
-                checkImportAlternatives(namedImp, NamedImport, ctx)(using outer)
-              else if (isPossibleImport(WildImport) && !curImport.nn.importSym.isCompleting) {
-                val wildImp = wildImportRef(curImport.uncheckedNN)
+                checkImportAlternatives((namedImp, NamedImport), ctx)(using outer)
+              else if (isPossibleImport(WildImport) && !curImport.importSym.isCompleting) {
+                val wildImp = wildImportRef(curImport)
                 if (wildImp.exists)
-                  checkImportAlternatives(wildImp, WildImport, ctx)(using outer)
+                  checkImportAlternatives((wildImp, WildImport), ctx)(using outer)
                 else {
                   updateUnimported()
                   loop(ctx)(using outer)
@@ -559,7 +561,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       loop(NoContext)
     }
 
-    findRefRecur(NoType, BindingPrec.NothingBound, NoContext)
+    val (foundRef, foundPrec) = findRefRecur(NoResult, NoContext)
+    foundRef
   }
 
   /** If `tree`'s type is a `TermRef` identified by flow typing to be non-null, then
diff --git a/tests/pos/i18529/JCode1.java b/tests/pos/i18529/JCode1.java
new file mode 100644
index 000000000000..e1f12f852c00
--- /dev/null
+++ b/tests/pos/i18529/JCode1.java
@@ -0,0 +1,9 @@
+package bug.code;
+
+import bug.util.List;
+import bug.util.*;
+import java.util.*;
+
+public class JCode1 {
+    public void m1(List<Integer> xs) { return; }
+}
diff --git a/tests/pos/i18529/JCode2.java b/tests/pos/i18529/JCode2.java
new file mode 100644
index 000000000000..2a1ec812852c
--- /dev/null
+++ b/tests/pos/i18529/JCode2.java
@@ -0,0 +1,9 @@
+package bug.code;
+
+import bug.util.*;
+import bug.util.List;
+import java.util.*;
+
+public class JCode2 {
+    public void m1(List<Integer> xs) { return; }
+}
diff --git a/tests/pos/i18529/List.java b/tests/pos/i18529/List.java
new file mode 100644
index 000000000000..caf3c0b8036b
--- /dev/null
+++ b/tests/pos/i18529/List.java
@@ -0,0 +1,3 @@
+package bug.util;
+
+public final class List<E> {}
diff --git a/tests/pos/i18529/SCode1.scala b/tests/pos/i18529/SCode1.scala
new file mode 100644
index 000000000000..b6796b1540c6
--- /dev/null
+++ b/tests/pos/i18529/SCode1.scala
@@ -0,0 +1,9 @@
+package bug.code
+
+import bug.util.List
+import bug.util.*
+import java.util.*
+
+class SCode1 {
+  def work(xs: List[Int]): Unit = {}
+}
diff --git a/tests/pos/i18529/SCode2.scala b/tests/pos/i18529/SCode2.scala
new file mode 100644
index 000000000000..30fc7d0e6f91
--- /dev/null
+++ b/tests/pos/i18529/SCode2.scala
@@ -0,0 +1,9 @@
+package bug.code
+
+import bug.util.*
+import bug.util.List
+import java.util.*
+
+class SCode2 {
+  def work(xs: List[Int]): Unit = {}
+}
diff --git a/tests/pos/i18529/Test.scala b/tests/pos/i18529/Test.scala
new file mode 100644
index 000000000000..be7795442a7a
--- /dev/null
+++ b/tests/pos/i18529/Test.scala
@@ -0,0 +1 @@
+class Test

From ae0070392c63882231bc97b143c39b001a5bfbec Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Fri, 29 Nov 2024 15:43:07 +0100
Subject: [PATCH 243/306] Update a test related to library cc

---
 tests/neg-custom-args/captures/i21614.check | 22 ++++++++++-----------
 tests/neg-custom-args/captures/i21614.scala |  3 +++
 2 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/tests/neg-custom-args/captures/i21614.check b/tests/neg-custom-args/captures/i21614.check
index ced3ab7fd59a..f4967253455f 100644
--- a/tests/neg-custom-args/captures/i21614.check
+++ b/tests/neg-custom-args/captures/i21614.check
@@ -1,15 +1,15 @@
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i21614.scala:9:33 ----------------------------------------
-9 |  files.map((f: F) => new Logger(f)) // error, Q: can we make this pass (see #19076)?
-  |                                 ^
-  |                                 Found:    (f : F^)
-  |                                 Required: File^
-  |
-  | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i21614.scala:12:12 ---------------------------------------
-12 |  files.map(new Logger(_)) // error, Q: can we improve the error message?
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i21614.scala:12:33 ---------------------------------------
+12 |  files.map((f: F) => new Logger(f)) // error, Q: can we make this pass (see #19076)?
+   |                                 ^
+   |                                 Found:    (f : F^)
+   |                                 Required: File^
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i21614.scala:15:12 ---------------------------------------
+15 |  files.map(new Logger(_)) // error, Q: can we improve the error message?
    |            ^^^^^^^^^^^^^
-   |     Found:    (_$1: box File^{files*}) ->{files*} (ex$13: caps.Exists) -> box Logger{val f: File^{_$1}}^{ex$13}
-   |     Required: (_$1: box File^{files*}) -><fluid> box Logger{val f: File^?}^?
+   |     Found:    (_$1: box File^{files*}) ->{files*} (ex$16: caps.Exists) -> box Logger{val f: File^{_$1}}^{ex$16}
+   |     Required: (_$1: box File^{files*}) => box Logger{val f: File^?}^?
    |
    |     Note that the universal capability `cap`
    |     cannot be included in capture set ?
diff --git a/tests/neg-custom-args/captures/i21614.scala b/tests/neg-custom-args/captures/i21614.scala
index 69aef446e9e2..f5bab90f543b 100644
--- a/tests/neg-custom-args/captures/i21614.scala
+++ b/tests/neg-custom-args/captures/i21614.scala
@@ -2,6 +2,9 @@ import language.experimental.captureChecking
 import caps.Capability
 import caps.use
 
+trait List[+T]:
+  def map[U](f: T => U): List[U]
+
 trait File extends Capability
 class Logger(f: File^) extends Capability // <- will work if we remove the extends clause
 

From ca1b4c0ca4ac477ca8f7ad7a3a5c3078e8401726 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Oliver=20Bra=C4=8Devac?= <bracevac@users.noreply.github.com>
Date: Fri, 29 Nov 2024 16:05:01 +0100
Subject: [PATCH 244/306] Update MAINTENANCE.md

---
 MAINTENANCE.md | 55 +++++++++++++++++++++++++++++---------------------
 1 file changed, 32 insertions(+), 23 deletions(-)

diff --git a/MAINTENANCE.md b/MAINTENANCE.md
index 79e55e11d4a9..05b90cc90b86 100644
--- a/MAINTENANCE.md
+++ b/MAINTENANCE.md
@@ -63,39 +63,48 @@ At the end of their supervision period, the supervisor reports to the team durin
 
 ## Maintenance List
 
-The following is the list of all the principal areas of the compiler and the core team members who are responsible for their maintenance:
+The following is the list of all the principal areas of the compiler and the internal team members who are responsible for their maintenance:
 
 ### Compiler
-- Parser: @odersky, @hamzaremmal
-- Typer: @odersky, @smarter, (@dwijnand), @noti0nal
+- Parser: @odersky, @hamzaremmal, @KacperFKorban
+- Typer: @odersky, @smarter, (@dwijnand), @noti0nal, @EugeneFlesselle, @KacperFKorban, @bracevac
 - Erasure: @smarter, @odersky
-- Enums: @bishabosha
-- Derivation & Mirrors: @bishabosha, (@dwijnand), @EugeneFlesselle
-- Export: @bishabosha, @odersky
-- Pattern Matching: @dwijnand, (@liufengyun), @sjrd
-- Inline: @nicolasstucki, @odersky, @hamzaremmal
-- Metaprogramming (Quotes, Reflect, Staging): @nicolasstucki, @jchyb, @hamzaremmal
-- Match types: @sjrd, @dwijnand, @Decel, @Linyxus
+- Enums: 
+- Derivation & Mirrors: (@dwijnand), @EugeneFlesselle
+- Export: @odersky
+- Pattern Matching: @dwijnand, @sjrd, @noti0na1
+- Inline: @odersky, @jchyb, @hamzaremmal, @EugeneFlesselle
+- Metaprogramming (Quotes, Reflect, Staging): @jchyb, @hamzaremmal
+- Match types: @sjrd, @dwijnand, @Linyxus, @EugeneFlesselle
 - GADT: @dwijnand, @Linyxus
-- Initialization checker: @olhotak, @liufengyun
-- Safe nulls: @noti0na1, @olhotak
-- Transforms: @szymon-rd, @sjrd, @odersky, @smarter
-- tailrec: @sjrd, @mbovel
+- Initialization checker: 
+- Transforms: @sjrd, @odersky, @smarter
+- Tailrec: @sjrd, @mbovel
 - JS backend: @sjrd
-- JVM backend: @sjrd
-- Java-compat: @smarter, @dwijnand
-- Capture checker: @odersky, @Linyxus
+- JVM backend: @sjrd, @hamzaremmal
+- Java-compat: @smarter, @dwijnand, @hamzaremmal
+- Extension Methods: @odersky, @dwijnand
+- Safe nulls (experimental): @noti0na1
+- Capture checker (experimental): @odersky, @Linyxus, @bracevac, @noti0na1
+- Modularity (experimental): @KacperFKorban
+- Named Tuples (experimental): @odersky
 
 ### Tooling
-- REPL: @dwijnand, @prolativ
+- REPL: @dwijnand
+- Runner/CLI: @Gedochao, (@tgodzik)
+- IDE: @tgodzik, (@kasiaMarek)
 - Scaladoc: @Florian3k
-- SemanticDB: @tanishiking
-- Coverage: @TheElectronWill
-- Linting (especially unused warnings) / Reporting UX: @szymon-rd
+- SemanticDB: @natsukagami, (@tanishiking)
+- Coverage: @KacperFKorban 
+- Linting (especially unused warnings) / Reporting UX: @KacperFKorban
+- Presentation Compiler: @rochala, @tgodzik, @kasiaMarek, @natsukagami 
+- Debug Adapter: @adpi2, (@tgodzik)
+- Scastie: @rochala
 
 ### Infrastructure
-- CI: @hamzaremmal
+- CI: @hamzaremmal, (@WojciechMazur)
 - Community Build: @hamzaremmal
 - Open Community Build: @WojciechMazur
-- Vulpix: @dwijnand, @prolativ
+- Vulpix: @dwijnand, @prolativ, @hamzaremmal
 - Benchmarks: @mbovel
+- Releases: @WojciechMazur, @prolativ

From 31dd8558e9e9a5e3c080947bbf2192861427c128 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Sat, 30 Nov 2024 14:04:54 +0100
Subject: [PATCH 245/306] Fix namedTuples import

---
 tests/pos/named-tuple-downcast.scala | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/pos/named-tuple-downcast.scala b/tests/pos/named-tuple-downcast.scala
index 239089b60c3d..b9876623faf2 100644
--- a/tests/pos/named-tuple-downcast.scala
+++ b/tests/pos/named-tuple-downcast.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.namedTuples
+
 type Person = (name: String, age: Int)
 
 val Bob: Person = (name = "Bob", age = 33)

From 921e9e0faa63d31386d060a4c1f895e0a8857d33 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Thu, 21 Nov 2024 20:10:41 +0100
Subject: [PATCH 246/306] Make capture parameters and members bounded by CapSet
 by default

---
 compiler/src/dotty/tools/dotc/ast/untpd.scala | 10 ++++++---
 .../dotty/tools/dotc/parsing/Parsers.scala    |  9 +++++---
 .../captures/capset-bound2.scala              | 13 ++++++++++++
 .../captures/capset-members.scala             | 21 +++++++++++++++++++
 4 files changed, 47 insertions(+), 6 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/capset-bound2.scala
 create mode 100644 tests/neg-custom-args/captures/capset-members.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index e8e3646bd087..b91c7a712f4c 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -527,10 +527,14 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def makeCapsOf(tp: RefTree)(using Context): Tree =
     TypeApply(Select(scalaDot(nme.caps), nme.capsOf), tp :: Nil)
 
-  def makeCapsBound()(using Context): Tree =
-    makeRetaining(
+  // `type C^` and `[C^]` becomes:
+  // `type C >: CapSet <: CapSet^{cap}` and `[C >: CapSet <: CapSet^{cap}]`
+  def makeCapsBound()(using Context): TypeBoundsTree =
+    TypeBoundsTree(
       Select(scalaDot(nme.caps), tpnme.CapSet),
-      Nil, tpnme.retainsCap)
+      makeRetaining(
+        Select(scalaDot(nme.caps), tpnme.CapSet),
+        Nil, tpnme.retainsCap))
 
   def makeConstructor(tparams: List[TypeDef], vparamss: List[List[ValDef]], rhs: Tree = EmptyTree)(using Context): DefDef =
     DefDef(nme.CONSTRUCTOR, joinParams(tparams, vparamss), TypeTree(), rhs)
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 220053e277a5..a67bb72333e9 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -2240,7 +2240,7 @@ object Parsers {
       atSpan(in.offset):
         if in.isIdent(nme.UPARROW) && Feature.ccEnabled then
           in.nextToken()
-          TypeBoundsTree(EmptyTree, makeCapsBound())
+          makeCapsBound()
         else
           TypeBoundsTree(bound(SUPERTYPE), bound(SUBTYPE))
 
@@ -4057,8 +4057,11 @@ object Parsers {
               || sourceVersion.isAtLeast(`3.6`) && in.isColon =>
             makeTypeDef(typeAndCtxBounds(tname))
           case _ =>
-            syntaxErrorOrIncomplete(ExpectedTypeBoundOrEquals(in.token))
-            return EmptyTree // return to avoid setting the span to EmptyTree
+            if in.isIdent(nme.UPARROW) && Feature.ccEnabled then
+              makeTypeDef(typeAndCtxBounds(tname))
+            else
+              syntaxErrorOrIncomplete(ExpectedTypeBoundOrEquals(in.token))
+              return EmptyTree // return to avoid setting the span to EmptyTree
         }
       }
     }
diff --git a/tests/neg-custom-args/captures/capset-bound2.scala b/tests/neg-custom-args/captures/capset-bound2.scala
new file mode 100644
index 000000000000..679606f0e43c
--- /dev/null
+++ b/tests/neg-custom-args/captures/capset-bound2.scala
@@ -0,0 +1,13 @@
+import caps.*
+
+class IO
+
+def f[C^](io: IO^{C^}) = ???
+
+def test =
+  f[CapSet](???)
+  f[CapSet^{}](???)
+  f[CapSet^](???)
+  f[Nothing](???) // error
+  f[String](???) // error
+  
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/capset-members.scala b/tests/neg-custom-args/captures/capset-members.scala
new file mode 100644
index 000000000000..bcc92835b95f
--- /dev/null
+++ b/tests/neg-custom-args/captures/capset-members.scala
@@ -0,0 +1,21 @@
+import caps.*
+
+trait Abstract[X^]:
+  type C >: X <: CapSet^
+  def boom(): Unit^{C^}
+
+class Concrete extends Abstract[CapSet^{}]:
+  type C = CapSet^{}
+  def boom() = ()
+
+class Concrete2 extends Abstract[CapSet^{}]:
+  type C = CapSet^{} & CapSet^{}
+  def boom() = ()
+
+class Concrete3 extends Abstract[CapSet^{}]:
+  type C = CapSet^{} | CapSet^{}
+  def boom() = ()
+
+class Concrete4 extends Abstract[CapSet^{}]:
+  type C = Nothing // error
+  def boom() = ()

From c996062deea19cf9932d050ffae009a114a15895 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Sun, 24 Nov 2024 23:22:33 +0100
Subject: [PATCH 247/306] Correct rules for CapSet; update definition for
 Contains; fix tests

---
 .../src/dotty/tools/dotc/cc/CaptureRef.scala  | 23 +++++++++++++++----
 library/src/scala/caps.scala                  |  4 ++--
 .../captures/capture-poly.scala               |  2 +-
 tests/neg-custom-args/captures/i22005.scala   |  8 +++++++
 .../neg-custom-args/captures/use-capset.check | 16 ++++++-------
 .../neg-custom-args/captures/use-capset.scala |  2 --
 tests/neg/cc-poly-2.check                     |  7 ------
 tests/neg/cc-poly-2.scala                     |  2 +-
 tests/pos/cc-poly-source-capability.scala     |  5 ++--
 9 files changed, 42 insertions(+), 27 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/i22005.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
index 199114880c2b..a11e272685d9 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
@@ -100,7 +100,8 @@ trait CaptureRef extends TypeProxy, ValueType:
    *   x: x1.type /\ x1 subsumes y  ==>  x subsumes y
    *   TODO: Document path cases
    */
-  final def subsumes(y: CaptureRef)(using Context): Boolean =
+  // import reporting.trace
+  final def subsumes(y: CaptureRef)(using Context): Boolean = // trace.force(i"subsumes $this, $y"):
 
     def subsumingRefs(x: Type, y: Type): Boolean = x match
       case x: CaptureRef => y match
@@ -135,14 +136,28 @@ trait CaptureRef extends TypeProxy, ValueType:
               case _ => false
           || viaInfo(y.info)(subsumingRefs(this, _))
         case MaybeCapability(y1) => this.stripMaybe.subsumes(y1)
+        case y: TypeRef if y.symbol.info.derivesFrom(defn.Caps_CapSet) =>
+          y.info match
+            case _: TypeAlias => y.captureSetOfInfo.elems.forall(this.subsumes)
+            case TypeBounds(_, hi: CaptureRef) => this.subsumes(hi)
+            case _ => y.captureSetOfInfo.elems.forall(this.subsumes)
         case _ => false
     || this.match
         case ReachCapability(x1) => x1.subsumes(y.stripReach)
         case x: TermRef => viaInfo(x.info)(subsumingRefs(_, y))
         case x: TermParamRef => subsumesExistentially(x, y)
-        case x: TypeRef if x.symbol.info.derivesFrom(defn.Caps_CapSet) =>
-          x.captureSetOfInfo.elems.exists(_.subsumes(y))
-        case x: TypeRef => assumedContainsOf(x).contains(y)
+        case x: TypeRef if assumedContainsOf(x).contains(y) => true
+        case x: TypeRef if x.derivesFrom(defn.Caps_CapSet) =>
+          x.info match
+            case _: TypeAlias =>
+              x.captureSetOfInfo.elems.exists(_.subsumes(y))
+            case TypeBounds(lo: CaptureRef, _) =>
+              lo.subsumes(y)
+            case _ =>
+              x.captureSetOfInfo.elems.exists(_.subsumes(y))
+        case AnnotatedType(parent, ann)
+        if ann.symbol.isRetains && parent.derivesFrom(defn.Caps_CapSet) =>
+          ann.tree.toCaptureSet.elems.exists(_.subsumes(y))
         case _ => false
   end subsumes
 
diff --git a/library/src/scala/caps.scala b/library/src/scala/caps.scala
index 53c4ae7dc0dd..da099c4afab6 100644
--- a/library/src/scala/caps.scala
+++ b/library/src/scala/caps.scala
@@ -22,12 +22,12 @@ import annotation.{experimental, compileTimeOnly, retainsCap}
   /** A type constraint expressing that the capture set `C` needs to contain
    *  the capability `R`
    */
-  sealed trait Contains[C <: CapSet @retainsCap, R <: Singleton]
+  sealed trait Contains[+C >: CapSet <: CapSet @retainsCap, R <: Singleton]
 
   /** The only implementation of `Contains`. The constraint that `{R} <: C` is
    *  added separately by the capture checker.
    */
-  given containsImpl[C <: CapSet @retainsCap, R <: Singleton]: Contains[C, R]()
+  given containsImpl[C >: CapSet <: CapSet @retainsCap, R <: Singleton]: Contains[C, R]()
 
   /** A wrapper indicating a type variable in a capture argument list of a
    *  @retains annotation. E.g. `^{x, Y^}` is represented as `@retains(x, capsOf[Y])`.
diff --git a/tests/neg-custom-args/captures/capture-poly.scala b/tests/neg-custom-args/captures/capture-poly.scala
index a3a7a4c2a3d7..0a0d773a3f64 100644
--- a/tests/neg-custom-args/captures/capture-poly.scala
+++ b/tests/neg-custom-args/captures/capture-poly.scala
@@ -3,7 +3,7 @@ import caps.*
 trait Foo extends Capability
 
 trait CaptureSet:
-  type C <: CapSet^
+  type C^
 
 def capturePoly[C^](a: Foo^{C^}): Foo^{C^} = a
 def capturePoly2(c: CaptureSet)(a: Foo^{c.C^}): Foo^{c.C^} = a
diff --git a/tests/neg-custom-args/captures/i22005.scala b/tests/neg-custom-args/captures/i22005.scala
new file mode 100644
index 000000000000..a9dca999e42b
--- /dev/null
+++ b/tests/neg-custom-args/captures/i22005.scala
@@ -0,0 +1,8 @@
+import caps.*
+
+class IO
+class File(io: IO^)
+
+class Handler[C^]:
+  def f(file: File^): File^{C^} = file // error
+  def g(file: File^{C^}): File^ = file // ok
diff --git a/tests/neg-custom-args/captures/use-capset.check b/tests/neg-custom-args/captures/use-capset.check
index cb330daf67f8..74afaa05890f 100644
--- a/tests/neg-custom-args/captures/use-capset.check
+++ b/tests/neg-custom-args/captures/use-capset.check
@@ -1,19 +1,19 @@
--- Error: tests/neg-custom-args/captures/use-capset.scala:7:50 ---------------------------------------------------------
-7 |private def g[C^] = (xs: List[Object^{C^}]) => xs.head // error
+-- Error: tests/neg-custom-args/captures/use-capset.scala:5:50 ---------------------------------------------------------
+5 |private def g[C^] = (xs: List[Object^{C^}]) => xs.head // error
   |                                               ^^^^^^^
   |                                               Capture set parameter C leaks into capture scope of method g.
   |                                               To allow this, the type C should be declared with a @use annotation
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/use-capset.scala:13:22 -----------------------------------
-13 |  val _: () -> Unit = h // error: should be ->{io}
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/use-capset.scala:11:22 -----------------------------------
+11 |  val _: () -> Unit = h // error: should be ->{io}
    |                      ^
    |                      Found:    (h : () ->{io} Unit)
    |                      Required: () -> Unit
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/use-capset.scala:15:50 -----------------------------------
-15 |  val _: () -> List[Object^{io}] -> Object^{io} = h2 // error, should be ->{io}
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/use-capset.scala:13:50 -----------------------------------
+13 |  val _: () -> List[Object^{io}] -> Object^{io} = h2 // error, should be ->{io}
    |                                                  ^^
-   |                                          Found:    (h2 : () ->? (x$0: List[box Object^]^{}) ->{io} Object^{io})
-   |                                          Required: () -> List[box Object^{io}] -> Object^{io}
+   |                                      Found:    (h2 : () ->? (x$0: List[box Object^{io}]^{}) ->{io} Object^{io})
+   |                                      Required: () -> List[box Object^{io}] -> Object^{io}
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/use-capset.scala b/tests/neg-custom-args/captures/use-capset.scala
index 6010e955f867..74288d616396 100644
--- a/tests/neg-custom-args/captures/use-capset.scala
+++ b/tests/neg-custom-args/captures/use-capset.scala
@@ -1,7 +1,5 @@
 import caps.{use, CapSet}
 
-
-
 def f[C^](@use xs: List[Object^{C^}]): Unit = ???
 
 private def g[C^] = (xs: List[Object^{C^}]) => xs.head // error
diff --git a/tests/neg/cc-poly-2.check b/tests/neg/cc-poly-2.check
index 0615ce19b5ea..7a2882775a75 100644
--- a/tests/neg/cc-poly-2.check
+++ b/tests/neg/cc-poly-2.check
@@ -1,10 +1,3 @@
--- [E007] Type Mismatch Error: tests/neg/cc-poly-2.scala:13:15 ---------------------------------------------------------
-13 |    f[Nothing](d) // error
-   |               ^
-   |               Found:    (d : Test.D^)
-   |               Required: Test.D
-   |
-   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg/cc-poly-2.scala:14:19 ---------------------------------------------------------
 14 |    f[CapSet^{c1}](d) // error
    |                   ^
diff --git a/tests/neg/cc-poly-2.scala b/tests/neg/cc-poly-2.scala
index c5e5df6540da..809fa8ae077c 100644
--- a/tests/neg/cc-poly-2.scala
+++ b/tests/neg/cc-poly-2.scala
@@ -10,7 +10,7 @@ object Test:
 
   def test(c1: C, c2: C) =
     val d: D^ = D()
-    f[Nothing](d) // error
+    // f[Nothing](d) // already rule out at typer
     f[CapSet^{c1}](d) // error
     val x = f(d)
     val _: D^{c1} = x // error
diff --git a/tests/pos/cc-poly-source-capability.scala b/tests/pos/cc-poly-source-capability.scala
index 363f261dadc1..6f6bdd91d20a 100644
--- a/tests/pos/cc-poly-source-capability.scala
+++ b/tests/pos/cc-poly-source-capability.scala
@@ -20,13 +20,14 @@ import caps.use
 
   def test1(async1: Async, @use others: List[Async]) =
     val src = Source[CapSet^{async1, others*}]
+    val _: Set[Listener^{async1, others*}] = src.allListeners
     val lst1 = listener(async1)
     val lsts = others.map(listener)
     val _: List[Listener^{others*}] = lsts
     src.register{lst1}
     src.register(listener(async1))
-    lsts.foreach(src.register)
-    others.map(listener).foreach(src.register)
+    lsts.foreach(src.register(_)) // TODO: why we need to use _ explicitly here?
+    others.map(listener).foreach(src.register(_))
     val ls = src.allListeners
     val _: Set[Listener^{async1, others*}] = ls
 

From 8a15af3976715da2504f62862f176a1146df6aef Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Tue, 26 Nov 2024 01:57:42 +0100
Subject: [PATCH 248/306] Refine subsumes rule; fix test

---
 .../src/dotty/tools/dotc/cc/CaptureRef.scala  | 24 ++++++++++++-------
 .../captures/cc-poly-varargs.scala            | 21 +++++++++-------
 2 files changed, 28 insertions(+), 17 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
index a11e272685d9..ec3e1908e1b5 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
@@ -93,15 +93,21 @@ trait CaptureRef extends TypeProxy, ValueType:
   final def invalidateCaches() =
     myCaptureSetRunId = NoRunId
 
-  /** x subsumes x
-   *   this subsumes this.f
+  /**  x subsumes x
+   *   x subsumes x.f
+   *   x =:= y ==> x subsumes y
    *   x subsumes y  ==>  x* subsumes y, x subsumes y?
    *   x subsumes y  ==>  x* subsumes y*, x? subsumes y?
    *   x: x1.type /\ x1 subsumes y  ==>  x subsumes y
-   *   TODO: Document path cases
+   *   X = CapSet^cx, exists rx in cx, rx subsumes y ==>  X subsumes y
+   *   Y = CapSet^cy, forall ry in cy, x subsumes ry ==>  x subsumes Y
+   *   X: CapSet^c1...CapSet^c2, (CapSet^c1) subsumes y  ==> X subsumes y
+   *   Y: CapSet^c1...CapSet^c2, x subsumes (CapSet^c2) ==> x subsumes Y
+   *   Contains[X, y]  ==>  X subsumes y
+   *
+   *   TODO: Document cases with more comments.
    */
-  // import reporting.trace
-  final def subsumes(y: CaptureRef)(using Context): Boolean = // trace.force(i"subsumes $this, $y"):
+  final def subsumes(y: CaptureRef)(using Context): Boolean =
 
     def subsumingRefs(x: Type, y: Type): Boolean = x match
       case x: CaptureRef => y match
@@ -136,11 +142,13 @@ trait CaptureRef extends TypeProxy, ValueType:
               case _ => false
           || viaInfo(y.info)(subsumingRefs(this, _))
         case MaybeCapability(y1) => this.stripMaybe.subsumes(y1)
-        case y: TypeRef if y.symbol.info.derivesFrom(defn.Caps_CapSet) =>
+        case y: TypeRef if y.derivesFrom(defn.Caps_CapSet) =>
           y.info match
-            case _: TypeAlias => y.captureSetOfInfo.elems.forall(this.subsumes)
             case TypeBounds(_, hi: CaptureRef) => this.subsumes(hi)
             case _ => y.captureSetOfInfo.elems.forall(this.subsumes)
+        case AnnotatedType(parent, ann)
+        if ann.symbol.isRetains && parent.derivesFrom(defn.Caps_CapSet) =>
+          ann.tree.toCaptureSet.elems.forall(this.subsumes)
         case _ => false
     || this.match
         case ReachCapability(x1) => x1.subsumes(y.stripReach)
@@ -149,8 +157,6 @@ trait CaptureRef extends TypeProxy, ValueType:
         case x: TypeRef if assumedContainsOf(x).contains(y) => true
         case x: TypeRef if x.derivesFrom(defn.Caps_CapSet) =>
           x.info match
-            case _: TypeAlias =>
-              x.captureSetOfInfo.elems.exists(_.subsumes(y))
             case TypeBounds(lo: CaptureRef, _) =>
               lo.subsumes(y)
             case _ =>
diff --git a/tests/pos-custom-args/captures/cc-poly-varargs.scala b/tests/pos-custom-args/captures/cc-poly-varargs.scala
index ac76c47d6dd5..0d2478f37bdf 100644
--- a/tests/pos-custom-args/captures/cc-poly-varargs.scala
+++ b/tests/pos-custom-args/captures/cc-poly-varargs.scala
@@ -1,17 +1,22 @@
-trait Cancellable
+abstract class Source[+T, Cap^]:
+  def transformValuesWith[U](f: (T -> U)^{Cap^}): Source[U, Cap]^{this, f} = ???
 
-abstract class Source[+T, Cap^]
-
-extension[T, Cap^](src: Source[T, Cap]^)
-  def transformValuesWith[U](f: (T -> U)^{Cap^}): Source[U, Cap]^{src, f} = ???
+// TODO: The extension version of `transformValuesWith` doesn't work currently.
+// extension[T, Cap^](src: Source[T, Cap]^)
+//   def transformValuesWith[U](f: (T -> U)^{Cap^}): Source[U, Cap]^{src, f} = ???
 
 def race[T, Cap^](sources: Source[T, Cap]^{Cap^}*): Source[T, Cap]^{Cap^} = ???
 
-def either[T1, T2, Cap^](src1: Source[T1, Cap]^{Cap^}, src2: Source[T2, Cap]^{Cap^}): Source[Either[T1, T2], Cap]^{Cap^} =
+def either[T1, T2, Cap^](
+    src1: Source[T1, Cap]^{Cap^},
+    src2: Source[T2, Cap]^{Cap^}): Source[Either[T1, T2], Cap]^{Cap^} =
   val left = src1.transformValuesWith(Left(_))
   val right = src2.transformValuesWith(Right(_))
-  race(left, right)
-
+  race[Either[T1, T2], Cap](left, right)
+  // An explcit type argument is required here because the second argument is
+  // inferred as `CapSet^{Cap^}` instead of `Cap`.
+  // Although `CapSet^{Cap^}` subsums `Cap` in terms of capture set,
+  // `Cap` is not a subtype of `CapSet^{Cap^}` in terms of subtyping.
 
 
 

From 092b358a9b6903cc2732affaf89c6e3bcb2c66f9 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Tue, 26 Nov 2024 15:30:40 +0100
Subject: [PATCH 249/306] Add constraint to capsOf

---
 .../src/dotty/tools/dotc/cc/CaptureSet.scala  |  4 ++-
 compiler/src/dotty/tools/dotc/cc/Setup.scala  |  5 ++-
 library/src/scala/caps.scala                  |  2 +-
 .../captures/capset-members.scala             |  4 +--
 tests/neg-custom-args/captures/i21868.scala   | 17 +++++-----
 tests/neg-custom-args/captures/i21868b.scala  | 33 +++++++++++++++++++
 .../captures/cc-poly-varargs.scala            | 10 ++----
 7 files changed, 53 insertions(+), 22 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/i21868b.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
index 5be4f6a2d1cd..1750e98f708a 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
@@ -161,7 +161,9 @@ sealed abstract class CaptureSet extends Showable:
     def debugInfo(using Context) = i"$this accountsFor $x, which has capture set ${x.captureSetOfInfo}"
     def test(using Context) = reporting.trace(debugInfo):
       elems.exists(_.subsumes(x))
-      || !x.isMaxCapability && x.captureSetOfInfo.subCaptures(this, frozen = true).isOK
+      || !x.isMaxCapability
+        && !x.derivesFrom(defn.Caps_CapSet)
+        && x.captureSetOfInfo.subCaptures(this, frozen = true).isOK
     comparer match
       case comparer: ExplainingTypeComparer => comparer.traceIndented(debugInfo)(test)
       case _ => test
diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index dfb9ec70bdba..9757e1af3cdb 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -117,6 +117,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
    *  The info of these symbols is made fluid.
    */
   def isPreCC(sym: Symbol)(using Context): Boolean =
+    // TODO: check type members as well
     sym.isTerm && sym.maybeOwner.isClass
     && !sym.is(Module)
     && !sym.owner.is(CaptureChecked)
@@ -866,7 +867,9 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
           if others.accountsFor(ref) then
             report.warning(em"redundant capture: $dom already accounts for $ref", pos)
 
-        if ref.captureSetOfInfo.elems.isEmpty && !ref.derivesFrom(defn.Caps_Capability) then
+        if ref.captureSetOfInfo.elems.isEmpty
+            && !ref.derivesFrom(defn.Caps_Capability)
+            && !ref.derivesFrom(defn.Caps_CapSet) then
           val deepStr = if ref.isReach then " deep" else ""
           report.error(em"$ref cannot be tracked since its$deepStr capture set is empty", pos)
         check(parent.captureSet, parent)
diff --git a/library/src/scala/caps.scala b/library/src/scala/caps.scala
index da099c4afab6..c35b3b55e813 100644
--- a/library/src/scala/caps.scala
+++ b/library/src/scala/caps.scala
@@ -33,7 +33,7 @@ import annotation.{experimental, compileTimeOnly, retainsCap}
    *  @retains annotation. E.g. `^{x, Y^}` is represented as `@retains(x, capsOf[Y])`.
    */
   @compileTimeOnly("Should be be used only internally by the Scala compiler")
-  def capsOf[CS]: Any = ???
+  def capsOf[CS >: CapSet <: CapSet @retainsCap]: Any = ???
 
   /** Reach capabilities x* which appear as terms in @retains annotations are encoded
    *  as `caps.reachCapability(x)`. When converted to CaptureRef types in capture sets
diff --git a/tests/neg-custom-args/captures/capset-members.scala b/tests/neg-custom-args/captures/capset-members.scala
index bcc92835b95f..2be4b4e32263 100644
--- a/tests/neg-custom-args/captures/capset-members.scala
+++ b/tests/neg-custom-args/captures/capset-members.scala
@@ -16,6 +16,6 @@ class Concrete3 extends Abstract[CapSet^{}]:
   type C = CapSet^{} | CapSet^{}
   def boom() = ()
 
-class Concrete4 extends Abstract[CapSet^{}]:
-  type C = Nothing // error
+class Concrete4 extends Abstract[CapSet^]:
+  type C = CapSet // error
   def boom() = ()
diff --git a/tests/neg-custom-args/captures/i21868.scala b/tests/neg-custom-args/captures/i21868.scala
index 929e770a21c6..4a617f98d07a 100644
--- a/tests/neg-custom-args/captures/i21868.scala
+++ b/tests/neg-custom-args/captures/i21868.scala
@@ -1,14 +1,13 @@
 import caps.*
 
 trait AbstractWrong:
-    type C <: CapSet
-    def boom(): Unit^{C^} // error
+  type C <: CapSet
+  def f(): Unit^{C^} // error
 
-trait Abstract:
-    type C <: CapSet^
-    def boom(): Unit^{C^}
-
-class Concrete extends Abstract:
-    type C = Nothing
-    def boom() = () // error
+trait Abstract1:
+  type C^
+  def f(): Unit^{C^}
 
+class Abstract2:
+  type C >: CapSet <: CapSet^
+  def f(): Unit^{C^}
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/i21868b.scala b/tests/neg-custom-args/captures/i21868b.scala
new file mode 100644
index 000000000000..feb21894908f
--- /dev/null
+++ b/tests/neg-custom-args/captures/i21868b.scala
@@ -0,0 +1,33 @@
+import caps.*
+
+class IO
+
+class File
+
+trait Abstract:
+  type C >: CapSet <: CapSet^
+  def f(file: File^{C^}): Unit
+
+class Concrete1 extends Abstract:
+  type C = CapSet
+  def f(file: File) = ()
+
+class Concrete2(io: IO^) extends Abstract:
+  type C = CapSet^{io}
+  def f(file: File^{io}) = ()
+
+class Concrete3(io: IO^) extends Abstract:
+  type C = CapSet^{io}
+  def f(file: File) = () // error
+
+trait Abstract2(io: IO^):
+  type C >: CapSet <: CapSet^{io}
+  def f(file: File^{C^}): Unit
+
+class Concrete4(io: IO^) extends Abstract2(io):
+  type C = CapSet
+  def f(file: File) = ()
+
+class Concrete5(io1: IO^, io2: IO^) extends Abstract2(io1):
+  type C = CapSet^{io2} // error
+  def f(file: File^{io2}) = ()
\ No newline at end of file
diff --git a/tests/pos-custom-args/captures/cc-poly-varargs.scala b/tests/pos-custom-args/captures/cc-poly-varargs.scala
index 0d2478f37bdf..168cc4d0275f 100644
--- a/tests/pos-custom-args/captures/cc-poly-varargs.scala
+++ b/tests/pos-custom-args/captures/cc-poly-varargs.scala
@@ -13,13 +13,7 @@ def either[T1, T2, Cap^](
   val left = src1.transformValuesWith(Left(_))
   val right = src2.transformValuesWith(Right(_))
   race[Either[T1, T2], Cap](left, right)
-  // An explcit type argument is required here because the second argument is
-  // inferred as `CapSet^{Cap^}` instead of `Cap`.
+  // Explcit type arguments are required here because the second argument
+  // is inferred as `CapSet^{Cap^}` instead of `Cap`.
   // Although `CapSet^{Cap^}` subsums `Cap` in terms of capture set,
   // `Cap` is not a subtype of `CapSet^{Cap^}` in terms of subtyping.
-
-
-
-
-
-

From acde5c0e06615c5f082e8225f77ddcbd7101e289 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Tue, 26 Nov 2024 16:31:22 +0100
Subject: [PATCH 250/306] Update test

---
 .../neg-custom-args/captures/capset-members.scala |  6 +++++-
 .../captures/capture-parameters.scala             |  9 +++++++++
 tests/neg-custom-args/captures/i21868b.scala      | 15 ++++++++++++++-
 3 files changed, 28 insertions(+), 2 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/capture-parameters.scala

diff --git a/tests/neg-custom-args/captures/capset-members.scala b/tests/neg-custom-args/captures/capset-members.scala
index 2be4b4e32263..7f975abbbc72 100644
--- a/tests/neg-custom-args/captures/capset-members.scala
+++ b/tests/neg-custom-args/captures/capset-members.scala
@@ -16,6 +16,10 @@ class Concrete3 extends Abstract[CapSet^{}]:
   type C = CapSet^{} | CapSet^{}
   def boom() = ()
 
-class Concrete4 extends Abstract[CapSet^]:
+class Concrete4(a: AnyRef^) extends Abstract[CapSet^{a}]:
   type C = CapSet // error
   def boom() = ()
+
+class Concrete5(a: AnyRef^) extends Abstract[CapSet^{a}]:
+  type C = CapSet^{} | CapSet^{a}
+  def boom() = ()
diff --git a/tests/neg-custom-args/captures/capture-parameters.scala b/tests/neg-custom-args/captures/capture-parameters.scala
new file mode 100644
index 000000000000..d59305ae0cb8
--- /dev/null
+++ b/tests/neg-custom-args/captures/capture-parameters.scala
@@ -0,0 +1,9 @@
+import caps.*
+
+class C
+
+def test[X^, Y^, Z >: X <: Y](x: C^{X^}, y: C^{Y^}, z: C^{Z^}) =
+  val x2z: C^{Z^} = x
+  val z2y: C^{Y^} = z
+  val x2y: C^{Y^} = x // error
+  
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/i21868b.scala b/tests/neg-custom-args/captures/i21868b.scala
index feb21894908f..cbecb485472e 100644
--- a/tests/neg-custom-args/captures/i21868b.scala
+++ b/tests/neg-custom-args/captures/i21868b.scala
@@ -1,3 +1,4 @@
+import language.experimental.modularity
 import caps.*
 
 class IO
@@ -20,7 +21,7 @@ class Concrete3(io: IO^) extends Abstract:
   type C = CapSet^{io}
   def f(file: File) = () // error
 
-trait Abstract2(io: IO^):
+trait Abstract2(tracked val io: IO^):
   type C >: CapSet <: CapSet^{io}
   def f(file: File^{C^}): Unit
 
@@ -29,5 +30,17 @@ class Concrete4(io: IO^) extends Abstract2(io):
   def f(file: File) = ()
 
 class Concrete5(io1: IO^, io2: IO^) extends Abstract2(io1):
+  type C = CapSet^{io2} // error
+  def f(file: File^{io2}) = ()
+
+trait Abstract3[X^]:
+  type C >: CapSet <: X
+  def f(file: File^{C^}): Unit
+
+class Concrete6(io: IO^) extends Abstract3[CapSet^{io}]:
+  type C = CapSet
+  def f(file: File) = ()
+
+class Concrete7(io1: IO^, io2: IO^) extends Abstract3[CapSet^{io1}]:
   type C = CapSet^{io2} // error
   def f(file: File^{io2}) = ()
\ No newline at end of file

From ed7eed681f406df43a3f8522cf08eaead8cb4497 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Tue, 26 Nov 2024 22:26:15 +0100
Subject: [PATCH 251/306] Apply suggestions from code review
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Oliver Bračevac <bracevac@users.noreply.github.com>
---
 tests/neg/cc-poly-2.scala                            | 2 +-
 tests/pos-custom-args/captures/cc-poly-varargs.scala | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/neg/cc-poly-2.scala b/tests/neg/cc-poly-2.scala
index 809fa8ae077c..c9249ba59437 100644
--- a/tests/neg/cc-poly-2.scala
+++ b/tests/neg/cc-poly-2.scala
@@ -10,7 +10,7 @@ object Test:
 
   def test(c1: C, c2: C) =
     val d: D^ = D()
-    // f[Nothing](d) // already rule out at typer
+    // f[Nothing](d) // already ruled out at typer
     f[CapSet^{c1}](d) // error
     val x = f(d)
     val _: D^{c1} = x // error
diff --git a/tests/pos-custom-args/captures/cc-poly-varargs.scala b/tests/pos-custom-args/captures/cc-poly-varargs.scala
index 168cc4d0275f..7f04ed987b28 100644
--- a/tests/pos-custom-args/captures/cc-poly-varargs.scala
+++ b/tests/pos-custom-args/captures/cc-poly-varargs.scala
@@ -13,7 +13,7 @@ def either[T1, T2, Cap^](
   val left = src1.transformValuesWith(Left(_))
   val right = src2.transformValuesWith(Right(_))
   race[Either[T1, T2], Cap](left, right)
-  // Explcit type arguments are required here because the second argument
+  // Explicit type arguments are required here because the second argument
   // is inferred as `CapSet^{Cap^}` instead of `Cap`.
-  // Although `CapSet^{Cap^}` subsums `Cap` in terms of capture set,
+  // Although `CapSet^{Cap^}` subsumes `Cap` in terms of capture sets,
   // `Cap` is not a subtype of `CapSet^{Cap^}` in terms of subtyping.

From bf8dcccf74a8e63e2d0fa723eea5687814f27a23 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Wed, 27 Nov 2024 05:42:03 +0100
Subject: [PATCH 252/306] Fix test

---
 .../tools/dotc/cc/CaptureAnnotation.scala     |  1 +
 .../src/dotty/tools/dotc/cc/CaptureRef.scala  | 12 +++++-----
 .../captures/capset-members.scala             | 22 ++++++++++---------
 tests/neg-custom-args/captures/i21868b.scala  | 13 +++++++----
 4 files changed, 28 insertions(+), 20 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureAnnotation.scala b/compiler/src/dotty/tools/dotc/cc/CaptureAnnotation.scala
index e437a8ad5d5f..f0018cc93d7e 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureAnnotation.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureAnnotation.scala
@@ -42,6 +42,7 @@ case class CaptureAnnotation(refs: CaptureSet, boxed: Boolean)(cls: Symbol) exte
       case cr: TermRef => ref(cr)
       case cr: TermParamRef => untpd.Ident(cr.paramName).withType(cr)
       case cr: ThisType => This(cr.cls)
+      // TODO: Will crash if the type is an annotated type, for example `cap?`
     }
     val arg = repeated(elems, TypeTree(defn.AnyType))
     New(symbol.typeRef, arg :: Nil)
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
index ec3e1908e1b5..6bfb83e07921 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
@@ -94,15 +94,15 @@ trait CaptureRef extends TypeProxy, ValueType:
     myCaptureSetRunId = NoRunId
 
   /**  x subsumes x
-   *   x subsumes x.f
-   *   x =:= y ==> x subsumes y
+   *   x =:= y       ==>  x subsumes y
+   *   x subsumes y  ==>  x subsumes y.f
    *   x subsumes y  ==>  x* subsumes y, x subsumes y?
    *   x subsumes y  ==>  x* subsumes y*, x? subsumes y?
    *   x: x1.type /\ x1 subsumes y  ==>  x subsumes y
-   *   X = CapSet^cx, exists rx in cx, rx subsumes y ==>  X subsumes y
-   *   Y = CapSet^cy, forall ry in cy, x subsumes ry ==>  x subsumes Y
-   *   X: CapSet^c1...CapSet^c2, (CapSet^c1) subsumes y  ==> X subsumes y
-   *   Y: CapSet^c1...CapSet^c2, x subsumes (CapSet^c2) ==> x subsumes Y
+   *   X = CapSet^cx, exists rx in cx, rx subsumes y     ==>  X subsumes y
+   *   Y = CapSet^cy, forall ry in cy, x subsumes ry     ==>  x subsumes Y
+   *   X: CapSet^c1...CapSet^c2, (CapSet^c1) subsumes y  ==>  X subsumes y
+   *   Y: CapSet^c1...CapSet^c2, x subsumes (CapSet^c2)  ==>  x subsumes Y
    *   Contains[X, y]  ==>  X subsumes y
    *
    *   TODO: Document cases with more comments.
diff --git a/tests/neg-custom-args/captures/capset-members.scala b/tests/neg-custom-args/captures/capset-members.scala
index 7f975abbbc72..984df756f48d 100644
--- a/tests/neg-custom-args/captures/capset-members.scala
+++ b/tests/neg-custom-args/captures/capset-members.scala
@@ -2,24 +2,26 @@ import caps.*
 
 trait Abstract[X^]:
   type C >: X <: CapSet^
-  def boom(): Unit^{C^}
+  // Don't test the return type using Unit, because it is a pure type.
+  def boom(): AnyRef^{C^}
 
 class Concrete extends Abstract[CapSet^{}]:
   type C = CapSet^{}
-  def boom() = ()
+  // TODO: Why do we get error without the return type here?
+  def boom(): AnyRef = new Object
 
 class Concrete2 extends Abstract[CapSet^{}]:
-  type C = CapSet^{} & CapSet^{}
-  def boom() = ()
+  type C = CapSet^{}
+  def boom(): AnyRef^ = new Object // error
 
 class Concrete3 extends Abstract[CapSet^{}]:
-  type C = CapSet^{} | CapSet^{}
-  def boom() = ()
+  def boom(): AnyRef = new Object
 
 class Concrete4(a: AnyRef^) extends Abstract[CapSet^{a}]:
   type C = CapSet // error
-  def boom() = ()
+  def boom(): AnyRef^{a} = a // error
 
-class Concrete5(a: AnyRef^) extends Abstract[CapSet^{a}]:
-  type C = CapSet^{} | CapSet^{a}
-  def boom() = ()
+class Concrete5(a: AnyRef^, b: AnyRef^) extends Abstract[CapSet^{a}]:
+  // TODO: Crash with the type member
+  // type C = CapSet^{a}
+  def boom(): AnyRef^{b} = b // error
diff --git a/tests/neg-custom-args/captures/i21868b.scala b/tests/neg-custom-args/captures/i21868b.scala
index cbecb485472e..bf512c411c19 100644
--- a/tests/neg-custom-args/captures/i21868b.scala
+++ b/tests/neg-custom-args/captures/i21868b.scala
@@ -29,9 +29,10 @@ class Concrete4(io: IO^) extends Abstract2(io):
   type C = CapSet
   def f(file: File) = ()
 
-class Concrete5(io1: IO^, io2: IO^) extends Abstract2(io1):
-  type C = CapSet^{io2} // error
-  def f(file: File^{io2}) = ()
+// TODO: Should be an error
+// class Concrete5(io1: IO^, io2: IO^) extends Abstract2(io1):
+//   type C = CapSet^{io2}
+//   def f(file: File^{io2}) = ()
 
 trait Abstract3[X^]:
   type C >: CapSet <: X
@@ -43,4 +44,8 @@ class Concrete6(io: IO^) extends Abstract3[CapSet^{io}]:
 
 class Concrete7(io1: IO^, io2: IO^) extends Abstract3[CapSet^{io1}]:
   type C = CapSet^{io2} // error
-  def f(file: File^{io2}) = ()
\ No newline at end of file
+  def f(file: File^{io2}) = ()
+
+class Concrete8(io1: IO^, io2: IO^) extends Abstract3[CapSet^{io1}]:
+  type C = CapSet^{io1}
+  def f(file: File^{io2}) = () // error
\ No newline at end of file

From 1fb05b2a82df1553a194502473b4f9a3232af470 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Wed, 27 Nov 2024 13:59:08 +0100
Subject: [PATCH 253/306] Fix crash error

---
 compiler/src/dotty/tools/dotc/cc/CaptureRef.scala   | 10 ++++------
 tests/neg-custom-args/captures/capset-members.scala |  7 +++++--
 tests/neg-custom-args/captures/i21868b.scala        | 12 +++++++++---
 3 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
index 6bfb83e07921..c4990b4413a8 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
@@ -146,9 +146,8 @@ trait CaptureRef extends TypeProxy, ValueType:
           y.info match
             case TypeBounds(_, hi: CaptureRef) => this.subsumes(hi)
             case _ => y.captureSetOfInfo.elems.forall(this.subsumes)
-        case AnnotatedType(parent, ann)
-        if ann.symbol.isRetains && parent.derivesFrom(defn.Caps_CapSet) =>
-          ann.tree.toCaptureSet.elems.forall(this.subsumes)
+        case CapturingType(parent, refs) if parent.derivesFrom(defn.Caps_CapSet) =>
+          refs.elems.forall(this.subsumes)
         case _ => false
     || this.match
         case ReachCapability(x1) => x1.subsumes(y.stripReach)
@@ -161,9 +160,8 @@ trait CaptureRef extends TypeProxy, ValueType:
               lo.subsumes(y)
             case _ =>
               x.captureSetOfInfo.elems.exists(_.subsumes(y))
-        case AnnotatedType(parent, ann)
-        if ann.symbol.isRetains && parent.derivesFrom(defn.Caps_CapSet) =>
-          ann.tree.toCaptureSet.elems.exists(_.subsumes(y))
+        case CapturingType(parent, refs) if parent.derivesFrom(defn.Caps_CapSet) =>
+          refs.elems.exists(_.subsumes(y))
         case _ => false
   end subsumes
 
diff --git a/tests/neg-custom-args/captures/capset-members.scala b/tests/neg-custom-args/captures/capset-members.scala
index 984df756f48d..540216852a43 100644
--- a/tests/neg-custom-args/captures/capset-members.scala
+++ b/tests/neg-custom-args/captures/capset-members.scala
@@ -22,6 +22,9 @@ class Concrete4(a: AnyRef^) extends Abstract[CapSet^{a}]:
   def boom(): AnyRef^{a} = a // error
 
 class Concrete5(a: AnyRef^, b: AnyRef^) extends Abstract[CapSet^{a}]:
-  // TODO: Crash with the type member
-  // type C = CapSet^{a}
+  type C = CapSet^{a}
   def boom(): AnyRef^{b} = b // error
+
+class Concrete6(a: AnyRef^, b: AnyRef^) extends Abstract[CapSet^{a}]:
+  def boom(): AnyRef^{b} = b // error
+  
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/i21868b.scala b/tests/neg-custom-args/captures/i21868b.scala
index bf512c411c19..490b5964b05b 100644
--- a/tests/neg-custom-args/captures/i21868b.scala
+++ b/tests/neg-custom-args/captures/i21868b.scala
@@ -30,9 +30,15 @@ class Concrete4(io: IO^) extends Abstract2(io):
   def f(file: File) = ()
 
 // TODO: Should be an error
-// class Concrete5(io1: IO^, io2: IO^) extends Abstract2(io1):
-//   type C = CapSet^{io2}
-//   def f(file: File^{io2}) = ()
+class Concrete5(io1: IO^, io2: IO^) extends Abstract2(io1):
+  // Similar to Concrete8, this type member should have overriding error.
+  // Parent class is Abstract2 { val io = Concrete5.this.io1 }
+  // Abstract2.this.C >: CapSet <: CapSet^{Concrete5.this.io1}
+  // Concrete5.this.C = CapSet^{Concrete5.this.io2}
+  // CapSet^{Concrete5.this.io2} !<:< CapSet^{Concrete5.this.io1}
+  // Hence, Concrete5.this.C !<:< Abstract2.this.C
+  type C = CapSet^{io2}
+  def f(file: File^{io2}) = ()
 
 trait Abstract3[X^]:
   type C >: CapSet <: X

From 82c5512009912b9b6535d0e5cf816695220a46f0 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Thu, 28 Nov 2024 01:15:14 +0100
Subject: [PATCH 254/306] Fix overriding check

---
 compiler/src/dotty/tools/dotc/cc/Setup.scala        |  1 -
 compiler/src/dotty/tools/dotc/typer/RefChecks.scala |  7 +++++--
 tests/neg-custom-args/captures/i21868b.scala        | 10 +---------
 3 files changed, 6 insertions(+), 12 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index 9757e1af3cdb..c5c362dbe8dc 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -117,7 +117,6 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
    *  The info of these symbols is made fluid.
    */
   def isPreCC(sym: Symbol)(using Context): Boolean =
-    // TODO: check type members as well
     sym.isTerm && sym.maybeOwner.isClass
     && !sym.is(Module)
     && !sym.owner.is(CaptureChecked)
diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
index 0ec9458cac5c..e03a2e3764c3 100644
--- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -21,6 +21,7 @@ import config.MigrationVersion
 import config.Printers.refcheck
 import reporting.*
 import Constants.Constant
+import cc.stripCapturing
 
 object RefChecks {
   import tpd.*
@@ -83,8 +84,10 @@ object RefChecks {
    *  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) =>
+    case ClassInfo(_, _, _, _, tp: Type) if (tp.stripCapturing ne cls.typeRef) && !cls.isOneOf(FinalOrModuleClass) =>
+      // println(i"upwardsThisType($cls) = ${cls.typeRef}, ne $tp")
       SkolemType(cls.appliedRef).withName(nme.this_)
     case _ =>
       cls.thisType
@@ -439,7 +442,7 @@ object RefChecks {
         val (mtp, otp) = if compareTypes then (memberTp(self), otherTp(self)) else (NoType, NoType)
         OverrideError(core, self, member, other, mtp, otp)
 
-      def compatTypes(memberTp: Type, otherTp: Type): Boolean =
+      def compatTypes(memberTp: Type, otherTp: Type): Boolean = // race.force(i"compatTypes $memberTp <:< $otherTp"):
         try
           isOverridingPair(member, memberTp, other, otherTp,
             fallBack = warnOnMigration(
diff --git a/tests/neg-custom-args/captures/i21868b.scala b/tests/neg-custom-args/captures/i21868b.scala
index 490b5964b05b..70f4e9c9d59c 100644
--- a/tests/neg-custom-args/captures/i21868b.scala
+++ b/tests/neg-custom-args/captures/i21868b.scala
@@ -29,15 +29,8 @@ class Concrete4(io: IO^) extends Abstract2(io):
   type C = CapSet
   def f(file: File) = ()
 
-// TODO: Should be an error
 class Concrete5(io1: IO^, io2: IO^) extends Abstract2(io1):
-  // Similar to Concrete8, this type member should have overriding error.
-  // Parent class is Abstract2 { val io = Concrete5.this.io1 }
-  // Abstract2.this.C >: CapSet <: CapSet^{Concrete5.this.io1}
-  // Concrete5.this.C = CapSet^{Concrete5.this.io2}
-  // CapSet^{Concrete5.this.io2} !<:< CapSet^{Concrete5.this.io1}
-  // Hence, Concrete5.this.C !<:< Abstract2.this.C
-  type C = CapSet^{io2}
+  type C = CapSet^{io2} // error
   def f(file: File^{io2}) = ()
 
 trait Abstract3[X^]:
@@ -53,5 +46,4 @@ class Concrete7(io1: IO^, io2: IO^) extends Abstract3[CapSet^{io1}]:
   def f(file: File^{io2}) = ()
 
 class Concrete8(io1: IO^, io2: IO^) extends Abstract3[CapSet^{io1}]:
-  type C = CapSet^{io1}
   def f(file: File^{io2}) = () // error
\ No newline at end of file

From 0750d5c4433ca0dba5b508ef46723c063da6b2c1 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Fri, 29 Nov 2024 12:49:36 +0100
Subject: [PATCH 255/306] Update Stepper in the library

---
 scala2-library-cc/src/scala/collection/Stepper.scala | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/scala2-library-cc/src/scala/collection/Stepper.scala b/scala2-library-cc/src/scala/collection/Stepper.scala
index 2f8abee4cffb..1723a110ad8a 100644
--- a/scala2-library-cc/src/scala/collection/Stepper.scala
+++ b/scala2-library-cc/src/scala/collection/Stepper.scala
@@ -53,7 +53,7 @@ trait Stepper[@specialized(Double, Int, Long) +A] {
     *
     * See method `trySplit` in [[java.util.Spliterator]].
     */
-  def trySplit(): Stepper[A]
+  def trySplit(): Stepper[A]^{this}
 
   /** Returns an estimate of the number of elements of this Stepper, or [[Long.MaxValue]]. See
     * method `estimateSize` in [[java.util.Spliterator]].
@@ -71,7 +71,7 @@ trait Stepper[@specialized(Double, Int, Long) +A] {
     * a [[java.util.Spliterator.OfInt]] (which is a `Spliterator[Integer]`) in the subclass [[IntStepper]]
     * (which is a `Stepper[Int]`).
     */
-  def spliterator[B >: A]: Spliterator[_]
+  def spliterator[B >: A]: Spliterator[_]^{this}
 
   /** Returns a Java [[java.util.Iterator]] corresponding to this Stepper.
     *
@@ -79,7 +79,7 @@ trait Stepper[@specialized(Double, Int, Long) +A] {
     * a [[java.util.PrimitiveIterator.OfInt]] (which is a `Iterator[Integer]`) in the subclass
     * [[IntStepper]] (which is a `Stepper[Int]`).
     */
-  def javaIterator[B >: A]: JIterator[_]
+  def javaIterator[B >: A]: JIterator[_]^{this}
 
   /** Returns an [[Iterator]] corresponding to this Stepper. Note that Iterators corresponding to
     * primitive Steppers box the elements.

From 1ed08dee4a26d6ae1806a6d5368ef0160bbe3a8d Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Fri, 29 Nov 2024 15:31:18 +0100
Subject: [PATCH 256/306] Clean comments

---
 compiler/src/dotty/tools/dotc/typer/RefChecks.scala | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
index e03a2e3764c3..7e53b38b5f98 100644
--- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -84,10 +84,8 @@ object RefChecks {
    *  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.stripCapturing ne cls.typeRef) && !cls.isOneOf(FinalOrModuleClass) =>
-      // println(i"upwardsThisType($cls) = ${cls.typeRef}, ne $tp")
       SkolemType(cls.appliedRef).withName(nme.this_)
     case _ =>
       cls.thisType
@@ -442,7 +440,7 @@ object RefChecks {
         val (mtp, otp) = if compareTypes then (memberTp(self), otherTp(self)) else (NoType, NoType)
         OverrideError(core, self, member, other, mtp, otp)
 
-      def compatTypes(memberTp: Type, otherTp: Type): Boolean = // race.force(i"compatTypes $memberTp <:< $otherTp"):
+      def compatTypes(memberTp: Type, otherTp: Type): Boolean =
         try
           isOverridingPair(member, memberTp, other, otherTp,
             fallBack = warnOnMigration(

From c1a083547e0b0cf80f20561eb6216cb0168e891f Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Sat, 30 Nov 2024 01:42:10 +0100
Subject: [PATCH 257/306] Drop syntax sugar for capture set member

---
 compiler/src/dotty/tools/dotc/cc/CaptureRef.scala   | 3 +++
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala | 7 ++-----
 tests/neg-custom-args/captures/capture-poly.scala   | 2 +-
 tests/neg-custom-args/captures/i21868.scala         | 8 ++++----
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
index c4990b4413a8..9bda9102cbb8 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureRef.scala
@@ -143,6 +143,9 @@ trait CaptureRef extends TypeProxy, ValueType:
           || viaInfo(y.info)(subsumingRefs(this, _))
         case MaybeCapability(y1) => this.stripMaybe.subsumes(y1)
         case y: TypeRef if y.derivesFrom(defn.Caps_CapSet) =>
+          // The upper and lower bounds don't have to be in the form of `CapSet^{...}`.
+          // They can be other capture set variables, which are bounded by `CapSet`,
+          // like `def test[X^, Y^, Z >: X <: Y]`.
           y.info match
             case TypeBounds(_, hi: CaptureRef) => this.subsumes(hi)
             case _ => y.captureSetOfInfo.elems.forall(this.subsumes)
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index a67bb72333e9..89f88faebc17 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -4057,11 +4057,8 @@ object Parsers {
               || sourceVersion.isAtLeast(`3.6`) && in.isColon =>
             makeTypeDef(typeAndCtxBounds(tname))
           case _ =>
-            if in.isIdent(nme.UPARROW) && Feature.ccEnabled then
-              makeTypeDef(typeAndCtxBounds(tname))
-            else
-              syntaxErrorOrIncomplete(ExpectedTypeBoundOrEquals(in.token))
-              return EmptyTree // return to avoid setting the span to EmptyTree
+            syntaxErrorOrIncomplete(ExpectedTypeBoundOrEquals(in.token))
+            return EmptyTree // return to avoid setting the span to EmptyTree
         }
       }
     }
diff --git a/tests/neg-custom-args/captures/capture-poly.scala b/tests/neg-custom-args/captures/capture-poly.scala
index 0a0d773a3f64..88989b418726 100644
--- a/tests/neg-custom-args/captures/capture-poly.scala
+++ b/tests/neg-custom-args/captures/capture-poly.scala
@@ -3,7 +3,7 @@ import caps.*
 trait Foo extends Capability
 
 trait CaptureSet:
-  type C^
+  type C >: CapSet <: CapSet^
 
 def capturePoly[C^](a: Foo^{C^}): Foo^{C^} = a
 def capturePoly2(c: CaptureSet)(a: Foo^{c.C^}): Foo^{c.C^} = a
diff --git a/tests/neg-custom-args/captures/i21868.scala b/tests/neg-custom-args/captures/i21868.scala
index 4a617f98d07a..876b68ac90a4 100644
--- a/tests/neg-custom-args/captures/i21868.scala
+++ b/tests/neg-custom-args/captures/i21868.scala
@@ -5,9 +5,9 @@ trait AbstractWrong:
   def f(): Unit^{C^} // error
 
 trait Abstract1:
-  type C^
+  type C >: CapSet <: CapSet^
   def f(): Unit^{C^}
 
-class Abstract2:
-  type C >: CapSet <: CapSet^
-  def f(): Unit^{C^}
\ No newline at end of file
+// class Abstract2:
+//   type C^
+//   def f(): Unit^{C^}
\ No newline at end of file

From 6866bd11544fd29ac3c12117184346134b54ca63 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Sat, 30 Nov 2024 01:45:07 +0100
Subject: [PATCH 258/306] Update comment

---
 compiler/src/dotty/tools/dotc/ast/untpd.scala | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index b91c7a712f4c..2acfc4cf86e3 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -527,8 +527,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def makeCapsOf(tp: RefTree)(using Context): Tree =
     TypeApply(Select(scalaDot(nme.caps), nme.capsOf), tp :: Nil)
 
-  // `type C^` and `[C^]` becomes:
-  // `type C >: CapSet <: CapSet^{cap}` and `[C >: CapSet <: CapSet^{cap}]`
+  // Capture set variable `[C^]` becomes: `[C >: CapSet <: CapSet^{cap}]`
   def makeCapsBound()(using Context): TypeBoundsTree =
     TypeBoundsTree(
       Select(scalaDot(nme.caps), tpnme.CapSet),

From 300043eae504350784b32e9f200b89da74480fa6 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Thu, 28 Nov 2024 12:47:28 +0100
Subject: [PATCH 259/306] Restore execution of parallel backend tests

---
 compiler/test/dotty/tools/dotc/CompilationTests.scala | 1 -
 1 file changed, 1 deletion(-)

diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index 9f72db6fc390..2c42204a4b4d 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -263,7 +263,6 @@ class CompilationTests {
   }
 
   // parallel backend tests
-  @Ignore("Temporarily disabled due to frequent timeouts")
   @Test def parallelBackend: Unit = {
     given TestGroup = TestGroup("parallelBackend")
     val parallelism = Runtime.getRuntime().availableProcessors().min(16)

From 790a50ae595aedc990b98fa8ce4e695e492e2bd0 Mon Sep 17 00:00:00 2001
From: Hamza Remmal <hamza@remmal.dev>
Date: Sat, 30 Nov 2024 14:42:10 +0100
Subject: [PATCH 260/306] chore: add workflow to trigger cc

---
 .github/workflows/test-cc.yml | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 .github/workflows/test-cc.yml

diff --git a/.github/workflows/test-cc.yml b/.github/workflows/test-cc.yml
new file mode 100644
index 000000000000..39d21b5b952f
--- /dev/null
+++ b/.github/workflows/test-cc.yml
@@ -0,0 +1,26 @@
+name: Scala 3 with Capture Checking
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    paths:
+      - .github/workflows/test-cc.yml
+      - scala2-library-cc/**
+      - scala2-library-cc-tasty/**
+      - compiler/src/dotty/tools/dotc/cc/**
+
+env:
+  DOTTY_CI_RUN: true
+  DEVELOCITY_ACCESS_KEY: ${{ secrets.DEVELOCITY_ACCESS_KEY }}
+
+jobs:
+  suite-with-stdlib-cc:
+    name: Test Suite with the CC Standard Library
+    runs-on: ubuntu-latest
+    steps:
+      - name: Git Checkout
+        uses: actions/checkout@v4
+      - name: Test with Scala 2 library with CC TASTy
+        run: ./project/scripts/sbt ";set ThisBuild/Build.scala2Library := Build.Scala2LibraryCCTasty ;scala3-bootstrapped/test"

From f47d103eb9dc3d679441d5efad6b3b08129ccca5 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Dec 2024 14:36:03 +0000
Subject: [PATCH 261/306] Bump webrick from 1.8.2 to 1.9.1 in /docs/_spec

Bumps [webrick](https://github.com/ruby/webrick) from 1.8.2 to 1.9.1.
- [Release notes](https://github.com/ruby/webrick/releases)
- [Commits](https://github.com/ruby/webrick/compare/v1.8.2...v1.9.1)

---
updated-dependencies:
- dependency-name: webrick
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 docs/_spec/Gemfile.lock | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/_spec/Gemfile.lock b/docs/_spec/Gemfile.lock
index c703a87bf993..38a790c676eb 100644
--- a/docs/_spec/Gemfile.lock
+++ b/docs/_spec/Gemfile.lock
@@ -41,7 +41,7 @@ GEM
     sass-listen (4.0.0)
       rb-fsevent (~> 0.9, >= 0.9.4)
       rb-inotify (~> 0.9, >= 0.9.7)
-    webrick (1.8.2)
+    webrick (1.9.1)
 
 PLATFORMS
   ruby

From 0650ed7880710d86e4a1abb71307849b7dc50180 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Dec 2024 14:56:21 +0000
Subject: [PATCH 262/306] Bump vedantmgoyal9/winget-releaser

Bumps [vedantmgoyal9/winget-releaser](https://github.com/vedantmgoyal9/winget-releaser) from b87a066d9e624db1394edcd947f8c4e5a7e30cd7 to 4ffc7888bffd451b357355dc214d43bb9f23917e.
- [Release notes](https://github.com/vedantmgoyal9/winget-releaser/releases)
- [Commits](https://github.com/vedantmgoyal9/winget-releaser/compare/b87a066d9e624db1394edcd947f8c4e5a7e30cd7...4ffc7888bffd451b357355dc214d43bb9f23917e)

---
updated-dependencies:
- dependency-name: vedantmgoyal9/winget-releaser
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/publish-winget.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/publish-winget.yml b/.github/workflows/publish-winget.yml
index 03ebc5d0fa7d..ba5877e63ec7 100644
--- a/.github/workflows/publish-winget.yml
+++ b/.github/workflows/publish-winget.yml
@@ -26,7 +26,7 @@ jobs:
   publish:
     runs-on: windows-latest
     steps:
-      - uses: vedantmgoyal9/winget-releaser@b87a066d9e624db1394edcd947f8c4e5a7e30cd7
+      - uses: vedantmgoyal9/winget-releaser@4ffc7888bffd451b357355dc214d43bb9f23917e
         with:
           identifier      : Scala.Scala.3
           version         : ${{ inputs.version }}

From 2d2b2ad4b27db3676389909c026791ea5f09d812 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 2 Dec 2024 16:16:47 +0000
Subject: [PATCH 263/306] Without boxing, just rerun that a named import is
 behind a wildcard one

---
 .../src/dotty/tools/dotc/typer/Typer.scala    | 87 ++++++++++---------
 1 file changed, 45 insertions(+), 42 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index c133d70ff9c7..7cd8e3496cd3 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -241,40 +241,44 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         !owner.isEmptyPackage || ctx.owner.enclosingPackageClass.isEmptyPackage
       }
 
-    import BindingPrec.*
-    type Result = (Type, BindingPrec)
-    val NoResult = (NoType, NothingBound)
-
     /** Find the denotation of enclosing `name` in given context `ctx`.
-     *  @param prevResult  A type that was found in a more deeply nested scope,
-     *                     and its precedence, or NoResult if nothing was found yet.
+     *  @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(prevResult: Result, prevCtx: Context)(using Context): Result = {
-      val (previous, prevPrec) = prevResult
+    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 newResult The newly found type and its precedence.
+       *  @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(newResult: Result, scala2pkg: Boolean = false)(using Context): Result =
-        val (found, newPrec) = newResult
+      def checkNewOrShadowed(found: Type, newPrec: BindingPrec, scala2pkg: Boolean = false)(using Context): Type =
         if !previous.exists || TypeComparer.isSameRef(previous, found) then
-           newResult
+           found
         else if (prevCtx.scope eq ctx.scope) && newPrec.beats(prevPrec) then
           // special cases: definitions beat imports, and named imports beat
           // wildcard imports, provided both are in contexts with same scope
-          newResult
+          found
+        else if newPrec == WildImport && ctx.outersIterator.exists: ctx =>
+          ctx.isImportContext && namedImportRef(ctx.importInfo.uncheckedNN).exists
+        then
+          // Don't let two ambiguous wildcard imports rule over
+          // a winning named import. See pos/i18529.
+          found
         else
           if !scala2pkg && !previous.isError && !found.isError then
             fail(AmbiguousReference(name, newPrec, prevPrec, prevCtx,
               isExtension = previous.termSymbol.is(ExtensionMethod) && found.termSymbol.is(ExtensionMethod)))
-          prevResult
+          previous
 
       /** Assemble and check alternatives to an imported reference. This implies:
        *   - If we expand an extension method (i.e. altImports != null),
@@ -287,13 +291,12 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
        *     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.
-       *  @param prevResult the previously found reference (which is an import), and
-       *                    the precedence of the reference (either NamedImport or WildImport)
+       *  @param previous   the previously found reference (which is an import)
+       *  @param prevPrec   the precedence of the reference (either NamedImport or WildImport)
        *  @param prevCtx    the context in which the reference was found
        *  @param using_Context the outer context of `precCtx`
        */
-      def checkImportAlternatives(prevResult: Result, prevCtx: Context)(using Context): Result =
-        val (previous, prevPrec) = prevResult
+      def checkImportAlternatives(previous: Type, prevPrec: BindingPrec, prevCtx: Context)(using Context): Type =
 
         def addAltImport(altImp: TermRef) =
           if !TypeComparer.isSameRef(previous, altImp)
@@ -308,20 +311,20 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
               if prevPrec == WildImport then
                 // Discard all previously found references and continue with `altImp`
                 altImports.clear()
-                checkImportAlternatives((altImp, NamedImport), ctx)(using ctx.outer)
+                checkImportAlternatives(altImp, NamedImport, ctx)(using ctx.outer)
               else
                 addAltImport(altImp)
-                checkImportAlternatives(prevResult, prevCtx)(using ctx.outer)
+                checkImportAlternatives(previous, prevPrec, prevCtx)(using ctx.outer)
             case _ =>
               if prevPrec == WildImport then
                 wildImportRef(curImport) match
                   case altImp: TermRef => addAltImport(altImp)
                   case _ =>
-              checkImportAlternatives(prevResult, prevCtx)(using ctx.outer)
+              checkImportAlternatives(previous, prevPrec, prevCtx)(using ctx.outer)
         else
-          val foundResult = findRefRecur(prevResult, prevCtx)
-          if foundResult._1 eq previous then checkNewOrShadowed(foundResult)(using prevCtx)
-          else foundResult
+          val found = findRefRecur(previous, prevPrec, prevCtx)
+          if found eq previous then checkNewOrShadowed(found, prevPrec)(using prevCtx)
+          else found
       end checkImportAlternatives
 
       def selection(imp: ImportInfo, name: Name, checkBounds: Boolean): Type =
@@ -411,10 +414,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         !noImports &&
         (prevPrec.ordinal < prec.ordinal || prevPrec == prec && (prevCtx.scope eq ctx.scope))
 
-      @tailrec def loop(lastCtx: Context)(using Context): Result =
-        if (ctx.scope eq EmptyScope) prevResult
+      @tailrec def loop(lastCtx: Context)(using Context): Type =
+        if (ctx.scope eq EmptyScope) previous
         else {
-          var result: Result = NoResult
+          var result: Type = NoType
           val curOwner = ctx.owner
 
           /** Is curOwner a package object that should be skipped?
@@ -513,7 +516,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                   effectiveOwner.thisType.select(name, defDenot).makePackageObjPrefixExplicit
                 }
               if !curOwner.is(Package) || isDefinedInCurrentUnit(defDenot) then
-                result = checkNewOrShadowed((found, Definition)) // no need to go further out, we found highest prec entry
+                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 =>
@@ -521,28 +524,29 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                   case _ =>
               else
                 if migrateTo3 && !foundUnderScala2.exists then
-                  foundUnderScala2 = checkNewOrShadowed((found, Definition), scala2pkg = true)._1
+                  foundUnderScala2 = checkNewOrShadowed(found, Definition, scala2pkg = true)
                 if (defDenot.symbol.is(Package))
-                  result = checkNewOrShadowed((previous orElse found, PackageClause))
+                  result = checkNewOrShadowed(previous orElse found, PackageClause)
                 else if (prevPrec.ordinal < PackageClause.ordinal)
-                  result = findRefRecur((found, PackageClause), ctx)(using ctx.outer)
+                  result = findRefRecur(found, PackageClause, ctx)(using ctx.outer)
             }
 
-          if result._1.exists then result
+          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)
-              prevResult // no more conflicts possible in this case
-            else if (isPossibleImport(NamedImport) && curImport != null && (curImport ne outer.importInfo)) {
-              def updateUnimported() = if curImport.unimported ne NoSymbol then unimported += curImport.unimported
-              val namedImp = namedImportRef(curImport)
+              previous // no more conflicts possible in this case
+            else if (isPossibleImport(NamedImport) && (curImport nen outer.importInfo)) {
+              val namedImp = namedImportRef(curImport.uncheckedNN)
               if (namedImp.exists)
-                checkImportAlternatives((namedImp, NamedImport), ctx)(using outer)
-              else if (isPossibleImport(WildImport) && !curImport.importSym.isCompleting) {
-                val wildImp = wildImportRef(curImport)
+                checkImportAlternatives(namedImp, NamedImport, ctx)(using outer)
+              else if (isPossibleImport(WildImport) && !curImport.nn.importSym.isCompleting) {
+                val wildImp = wildImportRef(curImport.uncheckedNN)
                 if (wildImp.exists)
-                  checkImportAlternatives((wildImp, WildImport), ctx)(using outer)
+                  checkImportAlternatives(wildImp, WildImport, ctx)(using outer)
                 else {
                   updateUnimported()
                   loop(ctx)(using outer)
@@ -561,8 +565,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       loop(NoContext)
     }
 
-    val (foundRef, foundPrec) = findRefRecur(NoResult, NoContext)
-    foundRef
+    findRefRecur(NoType, BindingPrec.NothingBound, NoContext)
   }
 
   /** If `tree`'s type is a `TermRef` identified by flow typing to be non-null, then

From 44be1f976e9d37ef18a5c776b5abc23f8bd773b7 Mon Sep 17 00:00:00 2001
From: Hamza Remmal <hamza@remmal.dev>
Date: Tue, 3 Dec 2024 14:45:00 +0100
Subject: [PATCH 264/306] chore: trigger cc tests when changing one of the cc
 tests

---
 .github/workflows/test-cc.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.github/workflows/test-cc.yml b/.github/workflows/test-cc.yml
index 39d21b5b952f..68113163ff93 100644
--- a/.github/workflows/test-cc.yml
+++ b/.github/workflows/test-cc.yml
@@ -10,6 +10,10 @@ on:
       - scala2-library-cc/**
       - scala2-library-cc-tasty/**
       - compiler/src/dotty/tools/dotc/cc/**
+      ## Capture Checking Tests
+      - tests/pos-custom-args/captures/**
+      - tests/run-custom-args/captures/**
+      - tests/neg-custom-args/captures/**
 
 env:
   DOTTY_CI_RUN: true

From 75f1ec78e68739bb9064081f8651840b2fce9b74 Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Tue, 3 Dec 2024 16:15:56 +0000
Subject: [PATCH 265/306] Add test cases project for presentation compiler

---
 build.sbt                                                | 1 +
 .../test/dotty/tools/pc/base/BasePCSuite.scala           | 8 ++++----
 project/Build.scala                                      | 9 +++++++--
 3 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/build.sbt b/build.sbt
index 9d29bfcb6d6a..9425c4eed1e9 100644
--- a/build.sbt
+++ b/build.sbt
@@ -36,6 +36,7 @@ val `dist-linux-aarch64` = Build.`dist-linux-aarch64`
 val `community-build` = Build.`community-build`
 val `sbt-community-build` = Build.`sbt-community-build`
 val `scala3-presentation-compiler` = Build.`scala3-presentation-compiler`
+val `scala3-presentation-compiler-testcases` = Build.`scala3-presentation-compiler-testcases`
 
 val sjsSandbox = Build.sjsSandbox
 val sjsJUnitTests = Build.sjsJUnitTests
diff --git a/presentation-compiler/test/dotty/tools/pc/base/BasePCSuite.scala b/presentation-compiler/test/dotty/tools/pc/base/BasePCSuite.scala
index 1158e433e732..a26c31ef084d 100644
--- a/presentation-compiler/test/dotty/tools/pc/base/BasePCSuite.scala
+++ b/presentation-compiler/test/dotty/tools/pc/base/BasePCSuite.scala
@@ -25,9 +25,9 @@ import org.junit.runner.RunWith
 import scala.meta.pc.CompletionItemPriority
 
 object TestResources:
-  val scalaLibrary = BuildInfo.ideTestsDependencyClasspath.map(_.toPath).toSeq
+  val classpath = BuildInfo.ideTestsDependencyClasspath.map(_.toPath).toSeq
   val classpathSearch =
-    ClasspathSearch.fromClasspath(scalaLibrary, ExcludedPackagesHandler.default)
+    ClasspathSearch.fromClasspath(classpath, ExcludedPackagesHandler.default)
 
 @RunWith(classOf[ReusableClassRunner])
 abstract class BasePCSuite extends PcAssertions:
@@ -38,11 +38,11 @@ abstract class BasePCSuite extends PcAssertions:
   val executorService: ScheduledExecutorService =
     Executors.newSingleThreadScheduledExecutor()
   val testingWorkspaceSearch = TestingWorkspaceSearch(
-    TestResources.scalaLibrary.map(_.toString)
+    TestResources.classpath.map(_.toString)
   )
 
   lazy val presentationCompiler: PresentationCompiler =
-    val myclasspath: Seq[Path] = TestResources.scalaLibrary
+    val myclasspath: Seq[Path] = TestResources.classpath
     val scalacOpts = scalacOptions(myclasspath)
     val search = new MockSymbolSearch(
       testingWorkspaceSearch,
diff --git a/project/Build.scala b/project/Build.scala
index b2aca3705d83..f36171aabbcd 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -1425,7 +1425,7 @@ object Build {
 
   lazy val `scala3-presentation-compiler` = project.in(file("presentation-compiler"))
     .withCommonSettings(Bootstrapped)
-    .dependsOn(`scala3-compiler-bootstrapped`, `scala3-library-bootstrapped`)
+    .dependsOn(`scala3-compiler-bootstrapped`, `scala3-library-bootstrapped`, `scala3-presentation-compiler-testcases`)
     .settings(presentationCompilerSettings)
     .settings(scala3PresentationCompilerBuildInfo)
     .settings(
@@ -1436,6 +1436,7 @@ object Build {
   def scala3PresentationCompilerBuildInfo =
     Seq(
       ideTestsDependencyClasspath := {
+        val testCasesLib = (`scala3-presentation-compiler-testcases` / Compile / classDirectory).value
         val dottyLib = (`scala3-library-bootstrapped` / Compile / classDirectory).value
         val scalaLib =
           (`scala3-library-bootstrapped` / Compile / dependencyClasspath)
@@ -1443,7 +1444,7 @@ object Build {
             .map(_.data)
             .filter(_.getName.matches("scala-library.*\\.jar"))
             .toList
-        dottyLib :: scalaLib
+        testCasesLib :: dottyLib :: scalaLib
         // Nil
       },
       Compile / buildInfoPackage := "dotty.tools.pc.buildinfo",
@@ -1503,6 +1504,10 @@ object Build {
     )
   }
 
+  lazy val `scala3-presentation-compiler-testcases` = project.in(file("presentation-compiler-testcases"))
+    .dependsOn(`scala3-compiler-bootstrapped`)
+    .settings(commonBootstrappedSettings)
+
   lazy val `scala3-language-server` = project.in(file("language-server")).
     dependsOn(dottyCompiler(Bootstrapped)).
     settings(commonBootstrappedSettings).

From 39f54dfdaccd518a4ddd54ca228a836495b62d99 Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Tue, 3 Dec 2024 16:22:20 +0000
Subject: [PATCH 266/306] Add test cases for #20560

---
 .../src/tests/macros/20560.scala                 | 16 ++++++++++++++++
 .../tools/pc/tests/hover/HoverTermSuite.scala    | 15 +++++++++++++++
 2 files changed, 31 insertions(+)
 create mode 100644 presentation-compiler-testcases/src/tests/macros/20560.scala

diff --git a/presentation-compiler-testcases/src/tests/macros/20560.scala b/presentation-compiler-testcases/src/tests/macros/20560.scala
new file mode 100644
index 000000000000..f72fc473f452
--- /dev/null
+++ b/presentation-compiler-testcases/src/tests/macros/20560.scala
@@ -0,0 +1,16 @@
+package tests.macros
+
+import scala.quoted.{Expr, Quotes}
+
+object Macro20560:
+  transparent inline def loadJavaSqlDriver: Int = ${ loadJavaSqlDriverImpl }
+
+  private def loadJavaSqlDriverImpl(using Quotes): Expr[42] =
+    Class.forName("java.sql.Driver")
+    '{42}
+
+  transparent inline def loadJavaSqlInexisting: Int = ${ loadJavaSqlInexistingImpl }
+
+  private def loadJavaSqlInexistingImpl(using Quotes): Expr[42] =
+    Class.forName("java.sql.Inexisting")
+    '{42}
diff --git a/presentation-compiler/test/dotty/tools/pc/tests/hover/HoverTermSuite.scala b/presentation-compiler/test/dotty/tools/pc/tests/hover/HoverTermSuite.scala
index 3e7a2549cbe0..ec1431187e56 100644
--- a/presentation-compiler/test/dotty/tools/pc/tests/hover/HoverTermSuite.scala
+++ b/presentation-compiler/test/dotty/tools/pc/tests/hover/HoverTermSuite.scala
@@ -596,6 +596,21 @@ class HoverTermSuite extends BaseHoverSuite:
         |""".stripMargin
     )
 
+  @Test def `i20560`=
+    check(
+      "val re@@s = tests.macros.Macro20560.loadJavaSqlDriver",
+      """```scala
+        |val res: Int
+        |```
+        |""".stripMargin
+    )
+
+  @Test def `i20560-2`=
+    check(
+      "val re@@s = tests.macros.Macro20560.loadJavaSqlInexisting",
+      "", // crashes in the Macro; no type info
+    )
+
   @Test def `import-rename` =
     check(
       """

From 115de9d85e83ef0e0f0622db21dbe399c3e7d191 Mon Sep 17 00:00:00 2001
From: kasiaMarek <kasia@marek.net>
Date: Wed, 4 Dec 2024 13:49:27 +0100
Subject: [PATCH 267/306] fix match error in keyword completions

---
 .../pc/completions/KeywordsCompletions.scala   |  1 +
 .../pc/tests/completion/CompletionSuite.scala  | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+)

diff --git a/presentation-compiler/src/main/dotty/tools/pc/completions/KeywordsCompletions.scala b/presentation-compiler/src/main/dotty/tools/pc/completions/KeywordsCompletions.scala
index abbf43174bc7..5dd3c8dead4d 100644
--- a/presentation-compiler/src/main/dotty/tools/pc/completions/KeywordsCompletions.scala
+++ b/presentation-compiler/src/main/dotty/tools/pc/completions/KeywordsCompletions.scala
@@ -216,6 +216,7 @@ object KeywordsCompletions:
       case untpd.TypeDef(_, template: Template) => checkForPossibleKeywords(template)
       case untpd.ModuleDef(_, template: Template) => checkForPossibleKeywords(template)
       case template: Template => checkForPossibleKeywords(template)
+      case _ => TemplateKeywordAvailability.default
     }.getOrElse(TemplateKeywordAvailability.default)
 
 
diff --git a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala
index ab28baea994b..4a30f9b06efa 100644
--- a/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala
+++ b/presentation-compiler/test/dotty/tools/pc/tests/completion/CompletionSuite.scala
@@ -2150,3 +2150,21 @@ class CompletionSuite extends BaseCompletionSuite:
          |""".stripMargin,
       assertSingleItem = false
     )
+
+  @Test def `metals-i6861` =
+    check(
+      """|trait Builder[Alg]:
+         |  def withTraces: String
+         |
+         |trait BuilderFactory:
+         |  def transformRouter(f: [Alg] => Builder[Alg] => String): BuilderFactory
+         |  def build: Unit
+         |
+         |def demo =
+         |  (??? : BuilderFactory)
+         |    .transformRouter([Alg] => _.withTraces)
+         |    .build@@
+         |""".stripMargin,
+      """|build: Unit
+         |""".stripMargin,
+    )

From de44d078ba68c1e0d503343a97b53195f5858ca1 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 4 Dec 2024 13:35:57 +0000
Subject: [PATCH 268/306] Introduce bindTypeSymbols utility in tpd.TreeOps

---
 compiler/src/dotty/tools/dotc/ast/tpd.scala      |  4 ++++
 .../dotty/tools/dotc/inlines/InlineReducer.scala | 16 +++-------------
 .../dotty/tools/dotc/typer/TypeAssigner.scala    |  8 +-------
 3 files changed, 8 insertions(+), 20 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 55021bf50ace..77e3387c5ce0 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -1137,6 +1137,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     /** Replace Ident nodes references to the underlying tree that defined them */
     def underlying(using Context): Tree = MapToUnderlying().transform(tree)
 
+    /** Collect all the TypeSymbol's of the type Bind nodes in the tree. */
+    def bindTypeSymbols(using Context): List[TypeSymbol] =
+      tree.collectSubTrees { case b: Bind if b.isType => b.symbol.asType }
+
     // --- Higher order traversal methods -------------------------------
 
     /** Apply `f` to each subtree of this tree */
diff --git a/compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala b/compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala
index 26fd52fb7138..0c321570bad5 100644
--- a/compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala
@@ -216,31 +216,21 @@ class InlineReducer(inliner: Inliner)(using Context):
       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 can contain Bind nodes in type parameter lists,
         // for that case tree looks like this:
         //   UnApply[t @ t](pats)(implicits): T[t]
         // Test case is pos/inline-caseclass.scala.
+        //
         // Alternatively, for explicitly specified type binds in type annotations like in
         //   case A(B): A[t]
         // the tree will look like this:
         //   Unapply[t](pats)(implicits) : T[t @ t]
         // and the binds will be found in the type tree instead
         // Test case is pos-macros/i15971
-        val tptBinds = getBinds(Set.empty[TypeSymbol], tpt)
+        val tptBinds = tpt.bindTypeSymbols.toSet
         val binds: Set[TypeSymbol] = pat match {
           case UnApply(TypeApply(_, tpts), _, _) =>
-            getBinds(Set.empty[TypeSymbol], tpts) ++ tptBinds
+            tpts.flatMap(_.bindTypeSymbols).toSet ++ tptBinds
           case _ => tptBinds
         }
 
diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
index 8751bd7dc9bb..6ce0f5f2517c 100644
--- a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -429,13 +429,7 @@ trait TypeAssigner {
   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 params1 = pat.bindTypeSymbols
         val params2 = pat.tpe match
           case AppliedType(tycon, args) =>
             val tparams = tycon.typeParamSymbols

From 2f6e60d5819873763609943962360c2f85f338bb Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 4 Dec 2024 13:36:55 +0000
Subject: [PATCH 269/306] Add type avoidance to inferred MT bound lubbing

---
 compiler/src/dotty/tools/dotc/typer/Typer.scala | 2 +-
 tests/pos/i21256.scala                          | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i21256.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 6bb5d1ee70ff..3434fa9f48fc 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2649,7 +2649,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       val lub = cases1.foldLeft(defn.NothingType: Type): (acc, case1) =>
         if !acc.exists then NoType
         else if case1.body.tpe.isProvisional then NoType
-        else acc | case1.body.tpe
+        else acc | TypeOps.avoid(case1.body.tpe, case1.pat.bindTypeSymbols)
       if lub.exists then
         if !lub.isAny then
           val msg = em"Match type upper bound inferred as $lub, where previously it was defaulted to Any"
diff --git a/tests/pos/i21256.scala b/tests/pos/i21256.scala
new file mode 100644
index 000000000000..e51484c73ef7
--- /dev/null
+++ b/tests/pos/i21256.scala
@@ -0,0 +1,5 @@
+object Test {
+  type MTWithBind[X] = X match {
+    case List[t] => t
+  }
+}

From fd7f451eeccfa8adb260d9b2cf86f47acfc1bc43 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 4 Dec 2024 13:38:05 +0000
Subject: [PATCH 270/306] Consider S a pseudo match alias

Fixes tests/pos/i18211.scala, where type avoidance would cause `S[? <:
Int]` which would otherwise be consider an unreducible wild and lead to
Any which isn't <: Int.
---
 compiler/src/dotty/tools/dotc/core/Types.scala | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 95c3b025b3ce..c5937074f4bc 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -4633,6 +4633,7 @@ object Types extends TypeUtils {
      */
     def isUnreducibleWild(using Context): Boolean =
       tycon.isLambdaSub && hasWildcardArg && !isMatchAlias
+        && !(args.sizeIs == 1 && defn.isCompiletime_S(tycon.typeSymbol)) // S is a pseudo Match Alias
 
     def tryCompiletimeConstantFold(using Context): Type =
       if myEvalRunId == ctx.runId then myEvalued

From 045b92f8c40cd6c173a02b8e7e0f989810178a5e Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 4 Dec 2024 16:07:15 +0000
Subject: [PATCH 271/306] Exclude testPickling difference

---
 compiler/test/dotc/pos-test-pickling.blacklist | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/test/dotc/pos-test-pickling.blacklist b/compiler/test/dotc/pos-test-pickling.blacklist
index ebdd414ea7f2..f35d527edf62 100644
--- a/compiler/test/dotc/pos-test-pickling.blacklist
+++ b/compiler/test/dotc/pos-test-pickling.blacklist
@@ -19,6 +19,7 @@ i12299a.scala
 i13871.scala
 i15181.scala
 i15922.scala
+i15926.scala
 t5031_2.scala
 i16997.scala
 i7414.scala

From 7d9771d983afdec4344d35642bcdf6adecd58a4b Mon Sep 17 00:00:00 2001
From: Jan Chyb <48855024+jchyb@users.noreply.github.com>
Date: Thu, 5 Dec 2024 13:01:08 +0100
Subject: [PATCH 272/306] Do not bring forward symbols created in transform and
 backend phases (#21865)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

In the i21844 issue minimization, first the `Macro.scala` and
`SuperClassWIthLazyVal.scala` compilation units are compiled, then in
the next run `SubClass.scala` is compiled. While compiling
`SuperClassWIthLazyVal.scala`, in the `LazyVals` transform phase, the
lzyINIT initialization fields are created. In the next run, while
compiling `SubClass.scala`, in the `GenBCode` phase, the compiler would
try to access the lzyINIT symbol, leading to a stale symbols crash.
While that symbol was a part of the SuperClass, it by design is not
generated for the Subclass - if we were to completely split those files
into 2 separate compilations, that symbol would be created only for the
classfile, but it would not be included in tasty, so the second
compilation would not try to access it.

This observation inspires the proposed fix, where if the symbol was
first created in or after the first transform phase (so after the
pickler phases), we do not try to bring forward this denotation, instead
returning NoDenotation.

In this PR, we also remove the fix proposed in i21559, as it is no
longer necessary with the newly added condition. There, since one of the
problematic Symbols created in `LazyVals` was moved elsewhere in
`MoveStatics`, we checked if that symbol could be found in a companion
object. I was not able to create any reproduction where a user defined
static would produce this problem, so I believe it’s safe to remove
that.
---
 compiler/src/dotty/tools/dotc/core/Denotations.scala   | 10 ++++------
 .../src/dotty/tools/dotc/core/SymDenotations.scala     |  4 ----
 tests/pos-macros/i21844/Macro.scala                    |  6 ++++++
 tests/pos-macros/i21844/SubClass.scala                 |  3 +++
 tests/pos-macros/i21844/SuperClassWithLazyVal.scala    |  2 ++
 5 files changed, 15 insertions(+), 10 deletions(-)
 create mode 100644 tests/pos-macros/i21844/Macro.scala
 create mode 100644 tests/pos-macros/i21844/SubClass.scala
 create mode 100644 tests/pos-macros/i21844/SuperClassWithLazyVal.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index 816b28177333..85ff51bc19de 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -2,7 +2,7 @@ package dotty.tools
 package dotc
 package core
 
-import SymDenotations.{ SymDenotation, ClassDenotation, NoDenotation, LazyType, stillValid, movedToCompanionClass, acceptStale, traceInvalid }
+import SymDenotations.{ SymDenotation, ClassDenotation, NoDenotation, LazyType, stillValid, acceptStale, traceInvalid }
 import Contexts.*
 import Names.*
 import NameKinds.*
@@ -742,6 +742,8 @@ object Denotations {
      *     the old version otherwise.
      *   - If the symbol did not have a denotation that was defined at the current phase
      *     return a NoDenotation instead.
+     *   - If the symbol was first defined in one of the transform phases (after pickling), it should not
+     *     be visible in new runs, so also return a NoDenotation.
      */
     private def bringForward()(using Context): SingleDenotation = {
       this match {
@@ -755,11 +757,7 @@ object Denotations {
       }
       if (!symbol.exists) return updateValidity()
       if (!coveredInterval.containsPhaseId(ctx.phaseId)) return NoDenotation
-      // Moved to a companion class, likely at a later phase (in MoveStatics)
-      this match {
-        case symd: SymDenotation if movedToCompanionClass(symd) => return NoDenotation
-        case _ =>
-      }
+      if (coveredInterval.firstPhaseId >= Phases.firstTransformPhase.id) return NoDenotation
       if (ctx.debug) traceInvalid(this)
       staleSymbolError
     }
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index f54b8a62fa25..e14e5cf0a728 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -2680,10 +2680,6 @@ object SymDenotations {
         stillValidInOwner(denot)
     }
 
-  def movedToCompanionClass(denot: SymDenotation)(using Context): Boolean =
-    val ownerCompanion = denot.maybeOwner.companionClass
-    stillValid(ownerCompanion) && ownerCompanion.unforcedDecls.contains(denot.name, denot.symbol)
-
   private[SymDenotations] def stillValidInOwner(denot: SymDenotation)(using Context): Boolean = try
     val owner = denot.maybeOwner.denot
     stillValid(owner)
diff --git a/tests/pos-macros/i21844/Macro.scala b/tests/pos-macros/i21844/Macro.scala
new file mode 100644
index 000000000000..31a2c3a5e76f
--- /dev/null
+++ b/tests/pos-macros/i21844/Macro.scala
@@ -0,0 +1,6 @@
+import scala.quoted.*
+
+object Macro:
+  inline def foo = ${ fooImpl }
+  def fooImpl(using Quotes): Expr[Int] =
+    '{ 123 }
diff --git a/tests/pos-macros/i21844/SubClass.scala b/tests/pos-macros/i21844/SubClass.scala
new file mode 100644
index 000000000000..54b0d970e515
--- /dev/null
+++ b/tests/pos-macros/i21844/SubClass.scala
@@ -0,0 +1,3 @@
+class SubClass extends SuperClass
+object SubClass:
+  val foo: Int = Macro.foo
diff --git a/tests/pos-macros/i21844/SuperClassWithLazyVal.scala b/tests/pos-macros/i21844/SuperClassWithLazyVal.scala
new file mode 100644
index 000000000000..60c270f2b277
--- /dev/null
+++ b/tests/pos-macros/i21844/SuperClassWithLazyVal.scala
@@ -0,0 +1,2 @@
+class SuperClass:
+  lazy val xyz: Int = 123

From cb73df2809e1894ff0ce1183b92c63b11cfef38f Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wojciech.mazur95@gmail.com>
Date: Thu, 5 Dec 2024 13:47:05 +0100
Subject: [PATCH 273/306] Update CLA check server url domain from lightbend.com
 to contibute.akka.io

---
 project/scripts/check-cla.sh | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/project/scripts/check-cla.sh b/project/scripts/check-cla.sh
index e4e489830f11..4ded66f3d3c3 100755
--- a/project/scripts/check-cla.sh
+++ b/project/scripts/check-cla.sh
@@ -5,16 +5,16 @@ echo "Pull request submitted by $AUTHOR";
 if [[ "$AUTHOR" == "github-actions[bot]" || "$AUTHOR" == "dependabot[bot]" ]] ; then
   echo "CLA check for $AUTHOR successful";
 else
-  signed=$(curl -s "https://www.lightbend.com/contribute/cla/scala/check/$AUTHOR" | jq -r ".signed");
+  signed=$(curl -s "https://contribute.akka.io/contribute/cla/scala/check/$AUTHOR" | jq -r ".signed");
   if [ "$signed" = "true" ] ; then
     echo "CLA check for $AUTHOR successful";
   else
     echo "CLA check for $AUTHOR failed";
     echo "Please sign the Scala CLA to contribute to the Scala compiler.";
-    echo "Go to https://www.lightbend.com/contribute/cla/scala and then";
+    echo "Go to https://contribute.akka.io/contribute/cla/scala and then";
     echo "comment on the pull request to ask for a new check.";
     echo "";
-    echo "Check if CLA is signed: https://www.lightbend.com/contribute/cla/scala/check/$AUTHOR";
+    echo "Check if CLA is signed: https://contribute.akka.io/contribute/cla/scala/check/$AUTHOR";
     exit 1;
   fi;
 fi;

From 191535b8723af53da834a72f99d71df134690370 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wojciech.mazur95@gmail.com>
Date: Thu, 5 Dec 2024 13:47:37 +0100
Subject: [PATCH 274/306] Follow redirects when checkting CLA

---
 project/scripts/check-cla.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project/scripts/check-cla.sh b/project/scripts/check-cla.sh
index 4ded66f3d3c3..dbb148d3c652 100755
--- a/project/scripts/check-cla.sh
+++ b/project/scripts/check-cla.sh
@@ -5,7 +5,7 @@ echo "Pull request submitted by $AUTHOR";
 if [[ "$AUTHOR" == "github-actions[bot]" || "$AUTHOR" == "dependabot[bot]" ]] ; then
   echo "CLA check for $AUTHOR successful";
 else
-  signed=$(curl -s "https://contribute.akka.io/contribute/cla/scala/check/$AUTHOR" | jq -r ".signed");
+  signed=$(curl -L -s "https://contribute.akka.io/contribute/cla/scala/check/$AUTHOR" | jq -r ".signed");
   if [ "$signed" = "true" ] ; then
     echo "CLA check for $AUTHOR successful";
   else

From 483920640f016c7ccdb31144df7ca602d99297fa Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Thu, 5 Dec 2024 16:45:53 +0100
Subject: [PATCH 275/306] Widen singleton types when computing fields from
 .Fields

Fixes #22018
---
 .../src/dotty/tools/dotc/typer/Typer.scala     |  2 +-
 tests/pos/i22018.scala                         | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i22018.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 6bb5d1ee70ff..1a3f5c2d97c3 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -868,7 +868,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           && pt != LhsProto
       then
         val pre = if !TypeOps.isLegalPrefix(qual.tpe) then SkolemType(qual.tpe) else qual.tpe
-        val fieldsType = pre.select(tpnme.Fields).dealias.simplified
+        val fieldsType = pre.select(tpnme.Fields).widenDealias.simplified
         val fields = fieldsType.namedTupleElementTypes
         typr.println(i"try dyn select $qual, $selName, $fields")
         fields.find(_._1 == selName) match
diff --git a/tests/pos/i22018.scala b/tests/pos/i22018.scala
new file mode 100644
index 000000000000..14f4733732be
--- /dev/null
+++ b/tests/pos/i22018.scala
@@ -0,0 +1,18 @@
+import scala.language.experimental.namedTuples
+
+class SelectableNT[A <: NamedTuple.AnyNamedTuple](val nt: A) extends Selectable:
+  type Fields = A
+  def selectDynamic(x: String) = ???
+
+object Test:
+
+  val a = (name = "foo", age = 1)
+
+  val sa = SelectableNT(a)
+  sa.name   // ok
+
+  type B = a.type
+  val b: B = a
+
+  val sb = SelectableNT(b)
+  sb.name   // fails
\ No newline at end of file

From 585dda9587bc95afb936eb18751fbf850cf3209c Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Sat, 21 Sep 2024 19:54:39 +0200
Subject: [PATCH 276/306] Refactor NotNullInfo to record every reference which
 is retracted once.

---
 .../dotty/tools/dotc/typer/Nullables.scala    | 32 +++++++---
 .../src/dotty/tools/dotc/typer/Typer.scala    | 15 ++++-
 tests/explicit-nulls/neg/i21380c.scala        |  6 +-
 tests/explicit-nulls/neg/i21619.scala         | 62 +++++++++++++++++++
 4 files changed, 100 insertions(+), 15 deletions(-)
 create mode 100644 tests/explicit-nulls/neg/i21619.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Nullables.scala b/compiler/src/dotty/tools/dotc/typer/Nullables.scala
index 3f071dad2d03..74623ed7b4e9 100644
--- a/compiler/src/dotty/tools/dotc/typer/Nullables.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Nullables.scala
@@ -52,15 +52,19 @@ object Nullables:
     val hiTree = if(hiTpe eq hi.typeOpt) hi else TypeTree(hiTpe)
     TypeBoundsTree(lo, hiTree, 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
+  /** A set of val or var references that are known to be not null,
+   *  a set of variable references that are not known (anymore) to be not null,
+   *  plus a set of variables that are known to be not null at any point.
    */
-  case class NotNullInfo(asserted: Set[TermRef], retracted: Set[TermRef]):
+  case class NotNullInfo(asserted: Set[TermRef], retracted: Set[TermRef], onceRetracted: Set[TermRef]):
     assert((asserted & retracted).isEmpty)
+    assert(retracted.subsetOf(onceRetracted))
 
     def isEmpty = this eq NotNullInfo.empty
 
-    def retractedInfo = NotNullInfo(Set(), retracted)
+    def retractedInfo = NotNullInfo(Set(), retracted, onceRetracted)
+
+    def onceRetractedInfo = NotNullInfo(Set(), onceRetracted, onceRetracted)
 
     /** The sequential combination with another not-null info */
     def seq(that: NotNullInfo): NotNullInfo =
@@ -68,19 +72,29 @@ object Nullables:
       else if that.isEmpty then this
       else NotNullInfo(
         this.asserted.union(that.asserted).diff(that.retracted),
-        this.retracted.union(that.retracted).diff(that.asserted))
+        this.retracted.union(that.retracted).diff(that.asserted),
+        this.onceRetracted.union(that.onceRetracted))
 
     /** 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))
+      NotNullInfo(
+        this.asserted.intersect(that.asserted),
+        this.retracted.union(that.retracted),
+        this.onceRetracted.union(that.onceRetracted))
+
+    def withOnceRetracted(that: NotNullInfo): NotNullInfo =
+      if that.isEmpty then this
+      else NotNullInfo(this.asserted, this.retracted, this.onceRetracted.union(that.onceRetracted))
 
   object NotNullInfo:
-    val empty = new NotNullInfo(Set(), Set())
+    val empty = new NotNullInfo(Set(), Set(), Set())
     def apply(asserted: Set[TermRef], retracted: Set[TermRef]): NotNullInfo =
-      if asserted.isEmpty && retracted.isEmpty then empty
-      else new NotNullInfo(asserted, retracted)
+      apply(asserted, retracted, retracted)
+    def apply(asserted: Set[TermRef], retracted: Set[TermRef], onceRetracted: Set[TermRef]): NotNullInfo =
+      if asserted.isEmpty && onceRetracted.isEmpty then empty
+      else new NotNullInfo(asserted, retracted, onceRetracted)
   end NotNullInfo
 
   /** A pair of not-null sets, depending on whether a condition is `true` or `false` */
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 6bb5d1ee70ff..588e4188c7bc 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1552,8 +1552,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     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
+      if result.thenp.tpe.isRef(defn.NothingClass) then
+        elsePathInfo.withOnceRetracted(thenPathInfo)
+      else if result.elsep.tpe.isRef(defn.NothingClass) then
+        thenPathInfo.withOnceRetracted(elsePathInfo)
       else thenPathInfo.alt(elsePathInfo)
     )
   end typedIf
@@ -2350,10 +2352,17 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     }: @unchecked
     val cases2 = cases2x.asInstanceOf[List[CaseDef]]
 
-    var nni = expr2.notNullInfo.retractedInfo
+    // Since we don't know at which point the the exception is thrown in the body,
+    // we have to collect any reference that is once retracted.
+    var nni = expr2.notNullInfo.onceRetractedInfo
+    // It is possible to have non-exhaustive cases, and some exceptions are thrown and not caught.
+    // Therefore, the code in the finallizer and after the try block can only rely on the retracted
+    // info from the cases' body.
     if cases2.nonEmpty then nni = nni.seq(cases2.map(_.notNullInfo.retractedInfo).reduce(_.alt(_)))
+
     val finalizer1 = typed(tree.finalizer, defn.UnitType)(using ctx.addNotNullInfo(nni))
     nni = nni.seq(finalizer1.notNullInfo)
+
     assignType(cpy.Try(tree)(expr2, cases2, finalizer1), expr2, cases2).withNotNullInfo(nni)
   }
 
diff --git a/tests/explicit-nulls/neg/i21380c.scala b/tests/explicit-nulls/neg/i21380c.scala
index f86a5638e4c8..de3cd5bafd6b 100644
--- a/tests/explicit-nulls/neg/i21380c.scala
+++ b/tests/explicit-nulls/neg/i21380c.scala
@@ -32,9 +32,9 @@ def test4: Int =
     case npe: NullPointerException => x = ""
     case _ => x = ""
   x.length // error
-  // Although the catch block here is exhaustive,
-  // it is possible that the exception is thrown and not caught.
-  // Therefore, the code after the try block can only rely on the retracted info.
+  // Although the catch block here is exhaustive, it is possible to have non-exhaustive cases,
+  // and some exceptions are thrown and not caught. Therefore, the code in the finallizer and
+  // after the try block can only rely on the retracted info from the cases' body.
 
 def test5: Int =
   var x: String | Null = null
diff --git a/tests/explicit-nulls/neg/i21619.scala b/tests/explicit-nulls/neg/i21619.scala
new file mode 100644
index 000000000000..1c93af707b73
--- /dev/null
+++ b/tests/explicit-nulls/neg/i21619.scala
@@ -0,0 +1,62 @@
+def test1: String =
+  var x: String | Null = null
+  x = ""
+  var i: Int = 1
+  try
+    i match
+      case _ =>
+        x = null
+        throw new Exception()
+    x = ""
+  catch
+    case e: Exception =>
+  x.replace("", "") // error
+
+def test2: String =
+  var x: String | Null = null
+  x = ""
+  var i: Int = 1
+  try
+    i match
+      case _ =>
+        x = null
+        throw new Exception()
+    x = ""
+  catch
+    case e: Exception =>
+      x = "e"
+  x.replace("", "") // error
+
+def test3: String =
+  var x: String | Null = null
+  x = ""
+  var i: Int = 1
+  try
+    i match
+      case _ =>
+        x = null
+        throw new Exception()
+    x = ""
+  catch
+    case e: Exception =>
+  finally
+    x = "f"
+  x.replace("", "") // ok
+
+def test4: String =
+  var x: String | Null = null
+  x = ""
+  var i: Int = 1
+  try
+    try
+      if i == 1 then
+        x = null
+        throw new Exception()
+      else
+        x = ""
+    catch
+      case _ =>
+    x = ""
+  catch
+    case _ =>
+  x.replace("", "") // error
\ No newline at end of file

From bcc9e68c778da3faa4dcb8b6c0258a48befff819 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Sun, 22 Sep 2024 17:03:39 +0200
Subject: [PATCH 277/306] Use a different rule for NotNullInfo

---
 .../dotty/tools/dotc/typer/Nullables.scala    | 44 ++++++-------------
 .../src/dotty/tools/dotc/typer/Typer.scala    | 34 +++++++-------
 tests/explicit-nulls/neg/i21619.scala         | 19 +++++++-
 3 files changed, 50 insertions(+), 47 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Nullables.scala b/compiler/src/dotty/tools/dotc/typer/Nullables.scala
index 74623ed7b4e9..62d2ccfb7200 100644
--- a/compiler/src/dotty/tools/dotc/typer/Nullables.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Nullables.scala
@@ -53,48 +53,35 @@ object Nullables:
     TypeBoundsTree(lo, hiTree, alias)
 
   /** A set of val or var references that are known to be not null,
-   *  a set of variable references that are not known (anymore) to be not null,
-   *  plus a set of variables that are known to be not null at any point.
+   *  plus a set of variable references that are once assigned to null.
    */
-  case class NotNullInfo(asserted: Set[TermRef], retracted: Set[TermRef], onceRetracted: Set[TermRef]):
-    assert((asserted & retracted).isEmpty)
-    assert(retracted.subsetOf(onceRetracted))
-
+  case class NotNullInfo(asserted: Set[TermRef], retracted: Set[TermRef]):
     def isEmpty = this eq NotNullInfo.empty
 
-    def retractedInfo = NotNullInfo(Set(), retracted, onceRetracted)
-
-    def onceRetractedInfo = NotNullInfo(Set(), onceRetracted, onceRetracted)
+    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),
-        this.onceRetracted.union(that.onceRetracted))
+        this.asserted.diff(that.retracted).union(that.asserted),
+        this.retracted.union(that.retracted))
 
     /** 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),
-        this.onceRetracted.union(that.onceRetracted))
+      NotNullInfo(this.asserted.intersect(that.asserted), this.retracted.union(that.retracted))
 
-    def withOnceRetracted(that: NotNullInfo): NotNullInfo =
-      if that.isEmpty then this
-      else NotNullInfo(this.asserted, this.retracted, this.onceRetracted.union(that.onceRetracted))
+    def withRetracted(that: NotNullInfo): NotNullInfo =
+      NotNullInfo(this.asserted, this.retracted.union(that.retracted))
 
   object NotNullInfo:
-    val empty = new NotNullInfo(Set(), Set(), Set())
+    val empty = new NotNullInfo(Set(), Set())
     def apply(asserted: Set[TermRef], retracted: Set[TermRef]): NotNullInfo =
-      apply(asserted, retracted, retracted)
-    def apply(asserted: Set[TermRef], retracted: Set[TermRef], onceRetracted: Set[TermRef]): NotNullInfo =
-      if asserted.isEmpty && onceRetracted.isEmpty then empty
-      else new NotNullInfo(asserted, retracted, onceRetracted)
+      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` */
@@ -247,16 +234,13 @@ object Nullables:
     *  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
+      if info.isEmpty 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))))
+      val mutables = infos.foldLeft(Set[TermRef]()):
+        (ms, info) => ms.union(info.asserted.filter(_.symbol.is(Mutable)))
       infos.extendWith(NotNullInfo(Set(), mutables))
 
   end extension
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 588e4188c7bc..8a72076527b9 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1553,9 +1553,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     def elsePathInfo = cond1.notNullInfoIf(false).seq(result.elsep.notNullInfo)
     result.withNotNullInfo(
       if result.thenp.tpe.isRef(defn.NothingClass) then
-        elsePathInfo.withOnceRetracted(thenPathInfo)
+        elsePathInfo.withRetracted(thenPathInfo)
       else if result.elsep.tpe.isRef(defn.NothingClass) then
-        thenPathInfo.withOnceRetracted(elsePathInfo)
+        thenPathInfo.withRetracted(elsePathInfo)
       else thenPathInfo.alt(elsePathInfo)
     )
   end typedIf
@@ -2150,9 +2150,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   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]]
-    var nni = sel.notNullInfo
-    if cases1.nonEmpty then nni = nni.seq(cases1.map(_.notNullInfo).reduce(_.alt(_)))
-    assignType(cpy.Match(tree)(sel, cases1), sel, cases1).withNotNullInfo(nni)
+    var nnInfo = sel.notNullInfo
+    if cases1.nonEmpty then nnInfo = nnInfo.seq(cases1.map(_.notNullInfo).reduce(_.alt(_)))
+    assignType(cpy.Match(tree)(sel, cases1), sel, cases1).withNotNullInfo(nnInfo)
   }
 
   def typedCases(cases: List[untpd.CaseDef], sel: Tree, wideSelType0: Type, pt: Type)(using Context): List[CaseDef] =
@@ -2334,7 +2334,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       val capabilityProof = caughtExceptions.reduce(OrType(_, _, true))
       untpd.Block(makeCanThrow(capabilityProof), expr)
 
-  def typedTry(tree: untpd.Try, pt: Type)(using Context): Try = {
+  def typedTry(tree: untpd.Try, pt: Type)(using Context): Try =
+    var nnInfo = NotNullInfo.empty
     val expr2 :: cases2x = harmonic(harmonize, pt) {
       // We want to type check tree.expr first to comput NotNullInfo, but `addCanThrowCapabilities`
       // uses the types of patterns in `tree.cases` to determine the capabilities.
@@ -2346,25 +2347,26 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       val casesEmptyBody1 = tree.cases.mapconserve(cpy.CaseDef(_)(body = EmptyTree))
       val casesEmptyBody2 = typedCases(casesEmptyBody1, EmptyTree, defn.ThrowableType, WildcardType)
       val expr1 = typed(addCanThrowCapabilities(tree.expr, casesEmptyBody2), pt.dropIfProto)
-      val casesCtx = ctx.addNotNullInfo(expr1.notNullInfo.retractedInfo)
+
+      // Since we don't know at which point the the exception is thrown in the body,
+      // we have to collect any reference that is once retracted.
+      nnInfo = expr1.notNullInfo.retractedInfo
+
+      val casesCtx = ctx.addNotNullInfo(nnInfo)
       val cases1 = typedCases(tree.cases, EmptyTree, defn.ThrowableType, pt.dropIfProto)(using casesCtx)
       expr1 :: cases1
     }: @unchecked
     val cases2 = cases2x.asInstanceOf[List[CaseDef]]
 
-    // Since we don't know at which point the the exception is thrown in the body,
-    // we have to collect any reference that is once retracted.
-    var nni = expr2.notNullInfo.onceRetractedInfo
     // It is possible to have non-exhaustive cases, and some exceptions are thrown and not caught.
     // Therefore, the code in the finallizer and after the try block can only rely on the retracted
     // info from the cases' body.
-    if cases2.nonEmpty then nni = nni.seq(cases2.map(_.notNullInfo.retractedInfo).reduce(_.alt(_)))
-
-    val finalizer1 = typed(tree.finalizer, defn.UnitType)(using ctx.addNotNullInfo(nni))
-    nni = nni.seq(finalizer1.notNullInfo)
+    if cases2.nonEmpty then
+      nnInfo = nnInfo.seq(cases2.map(_.notNullInfo.retractedInfo).reduce(_.alt(_)))
 
-    assignType(cpy.Try(tree)(expr2, cases2, finalizer1), expr2, cases2).withNotNullInfo(nni)
-  }
+    val finalizer1 = typed(tree.finalizer, defn.UnitType)(using ctx.addNotNullInfo(nnInfo))
+    nnInfo = nnInfo.seq(finalizer1.notNullInfo)
+    assignType(cpy.Try(tree)(expr2, cases2, finalizer1), expr2, cases2).withNotNullInfo(nnInfo)
 
   def typedTry(tree: untpd.ParsedTry, pt: Type)(using Context): Try =
     val cases: List[untpd.CaseDef] = tree.handler match
diff --git a/tests/explicit-nulls/neg/i21619.scala b/tests/explicit-nulls/neg/i21619.scala
index 1c93af707b73..244f993fd4e1 100644
--- a/tests/explicit-nulls/neg/i21619.scala
+++ b/tests/explicit-nulls/neg/i21619.scala
@@ -59,4 +59,21 @@ def test4: String =
     x = ""
   catch
     case _ =>
-  x.replace("", "") // error
\ No newline at end of file
+  x.replace("", "") // error
+
+def test5: Unit =
+  var x: String | Null = null
+  var y: String | Null = null
+  x = ""
+  y = ""
+  var i: Int = 1
+  try
+    i match
+      case _ =>
+        x = null
+        throw new Exception()
+    x = ""
+  catch
+    case _ =>
+  val z1: String = x.replace("", "") // error
+  val z2: String = y.replace("", "")
\ No newline at end of file

From 05c630acf9dd8b2ecb98f34b1f40bfc8ddb55ce8 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Fri, 11 Oct 2024 06:24:24 +0200
Subject: [PATCH 278/306] Consider cases with Nothing type

---
 .../src/dotty/tools/dotc/typer/Typer.scala    | 24 ++++++++++++-------
 tests/explicit-nulls/neg/i21380b.scala        | 18 ++++++++++++++
 2 files changed, 34 insertions(+), 8 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 8a72076527b9..5731b44368e6 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1552,9 +1552,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     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
+      if result.thenp.tpe.isNothingType then
         elsePathInfo.withRetracted(thenPathInfo)
-      else if result.elsep.tpe.isRef(defn.NothingClass) then
+      else if result.elsep.tpe.isNothingType then
         thenPathInfo.withRetracted(elsePathInfo)
       else thenPathInfo.alt(elsePathInfo)
     )
@@ -2141,20 +2141,28 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         case1
       }
       .asInstanceOf[List[CaseDef]]
-    var nni = sel.notNullInfo
-    if cases1.nonEmpty then nni = nni.seq(cases1.map(_.notNullInfo).reduce(_.alt(_)))
-    assignType(cpy.Match(tree)(sel, cases1), sel, cases1).cast(pt).withNotNullInfo(nni)
+    assignType(cpy.Match(tree)(sel, cases1), sel, cases1).cast(pt)
+      .withNotNullInfo(notNullInfoFromCases(sel.notNullInfo, cases1))
   }
 
   // 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]]
-    var nnInfo = sel.notNullInfo
-    if cases1.nonEmpty then nnInfo = nnInfo.seq(cases1.map(_.notNullInfo).reduce(_.alt(_)))
-    assignType(cpy.Match(tree)(sel, cases1), sel, cases1).withNotNullInfo(nnInfo)
+    assignType(cpy.Match(tree)(sel, cases1), sel, cases1)
+      .withNotNullInfo(notNullInfoFromCases(sel.notNullInfo, cases1))
   }
 
+  private def notNullInfoFromCases(initInfo: NotNullInfo, cases: List[CaseDef])(using Context): NotNullInfo =
+    var nnInfo = initInfo
+    if cases.nonEmpty then
+      val (nothingCases, normalCases) = cases.partition(_.body.tpe.isNothingType)
+      nnInfo = nothingCases.foldLeft(nnInfo):
+        (nni, c) => nni.withRetracted(c.notNullInfo)
+      if normalCases.nonEmpty then
+        nnInfo = nnInfo.seq(normalCases.map(_.notNullInfo).reduce(_.alt(_)))
+    nnInfo
+
   def typedCases(cases: List[untpd.CaseDef], sel: Tree, wideSelType0: Type, pt: Type)(using Context): List[CaseDef] =
     var caseCtx = ctx
     var wideSelType = wideSelType0
diff --git a/tests/explicit-nulls/neg/i21380b.scala b/tests/explicit-nulls/neg/i21380b.scala
index 83e23053547c..e4d0caa9e32f 100644
--- a/tests/explicit-nulls/neg/i21380b.scala
+++ b/tests/explicit-nulls/neg/i21380b.scala
@@ -18,4 +18,22 @@ def test3(i: Int) =
   i match
     case 1 if x != null => ()
     case _ => x = " "
+  x.trim() // ok
+
+def test4(i: Int) =
+  var x: String | Null = null
+  var y: String | Null = null
+  i match
+    case 1 => x = "1"
+    case _ => y = " "
+  x.trim() // error
+
+def test5(i: Int): String =
+  var x: String | Null = null
+  var y: String | Null = null
+  i match
+    case 1 => x = "1"
+    case _ =>
+      y = " "
+      return y
   x.trim() // ok
\ No newline at end of file

From d44147bc6ff5496dab9cc1569274dfb4b673ee09 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Mon, 14 Oct 2024 15:21:03 +0200
Subject: [PATCH 279/306] Apply suggestions from code review
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Ondřej Lhoták <olhotak@uwaterloo.ca>
---
 compiler/src/dotty/tools/dotc/typer/Nullables.scala | 7 +++++--
 compiler/src/dotty/tools/dotc/typer/Typer.scala     | 2 +-
 tests/explicit-nulls/neg/i21380c.scala              | 2 +-
 3 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Nullables.scala b/compiler/src/dotty/tools/dotc/typer/Nullables.scala
index 62d2ccfb7200..e6d764dc1be4 100644
--- a/compiler/src/dotty/tools/dotc/typer/Nullables.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Nullables.scala
@@ -52,8 +52,11 @@ object Nullables:
     val hiTree = if(hiTpe eq hi.typeOpt) hi else TypeTree(hiTpe)
     TypeBoundsTree(lo, hiTree, alias)
 
-  /** A set of val or var references that are known to be not null,
-   *  plus a set of variable references that are once assigned to null.
+  /** A set of val or var references that are known to be not null
+  * after the tree finishes executing normally (non-exceptionally),
+   *  plus a set of variable references that are ever assigned to null,
+   *  and may therefore be null if execution of the tree is interrupted
+   *  by an exception.
    */
   case class NotNullInfo(asserted: Set[TermRef], retracted: Set[TermRef]):
     def isEmpty = this eq NotNullInfo.empty
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 5731b44368e6..392a4e18c454 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2367,7 +2367,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val cases2 = cases2x.asInstanceOf[List[CaseDef]]
 
     // It is possible to have non-exhaustive cases, and some exceptions are thrown and not caught.
-    // Therefore, the code in the finallizer and after the try block can only rely on the retracted
+    // Therefore, the code in the finalizer and after the try block can only rely on the retracted
     // info from the cases' body.
     if cases2.nonEmpty then
       nnInfo = nnInfo.seq(cases2.map(_.notNullInfo.retractedInfo).reduce(_.alt(_)))
diff --git a/tests/explicit-nulls/neg/i21380c.scala b/tests/explicit-nulls/neg/i21380c.scala
index de3cd5bafd6b..9b7a721fbdf0 100644
--- a/tests/explicit-nulls/neg/i21380c.scala
+++ b/tests/explicit-nulls/neg/i21380c.scala
@@ -33,7 +33,7 @@ def test4: Int =
     case _ => x = ""
   x.length // error
   // Although the catch block here is exhaustive, it is possible to have non-exhaustive cases,
-  // and some exceptions are thrown and not caught. Therefore, the code in the finallizer and
+  // and some exceptions are thrown and not caught. Therefore, the code in the finalizer and
   // after the try block can only rely on the retracted info from the cases' body.
 
 def test5: Int =

From f859afe8e4ace35e026600bb784664dcbcdbda98 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Fri, 1 Nov 2024 09:07:18 +0100
Subject: [PATCH 280/306] Add terminated info

---
 .../dotty/tools/dotc/typer/Nullables.scala    | 43 ++++++++++++-------
 .../src/dotty/tools/dotc/typer/Typer.scala    | 27 ++++--------
 2 files changed, 36 insertions(+), 34 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Nullables.scala b/compiler/src/dotty/tools/dotc/typer/Nullables.scala
index e6d764dc1be4..30c65771d9c2 100644
--- a/compiler/src/dotty/tools/dotc/typer/Nullables.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Nullables.scala
@@ -53,37 +53,45 @@ object Nullables:
     TypeBoundsTree(lo, hiTree, alias)
 
   /** A set of val or var references that are known to be not null
-  * after the tree finishes executing normally (non-exceptionally),
+   *  after the tree finishes executing normally (non-exceptionally),
    *  plus a set of variable references that are ever assigned to null,
    *  and may therefore be null if execution of the tree is interrupted
    *  by an exception.
    */
-  case class NotNullInfo(asserted: Set[TermRef], retracted: Set[TermRef]):
+  case class NotNullInfo(asserted: Set[TermRef] | Null, retracted: Set[TermRef]):
     def isEmpty = this eq NotNullInfo.empty
 
     def retractedInfo = NotNullInfo(Set(), retracted)
 
+    def terminatedInfo = NotNullInfo(null, 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.diff(that.retracted).union(that.asserted),
-        this.retracted.union(that.retracted))
+      else
+        val newAsserted =
+          if this.asserted == null || that.asserted == null then null
+          else this.asserted.diff(that.retracted).union(that.asserted)
+        val newRetracted = this.retracted.union(that.retracted)
+        NotNullInfo(newAsserted, newRetracted)
 
     /** The alternative path combination with another not-null info. Used to merge
-     *  the nullability info of the two branches of an if.
+     *  the nullability info of the branches of an if or match.
      */
     def alt(that: NotNullInfo): NotNullInfo =
-      NotNullInfo(this.asserted.intersect(that.asserted), this.retracted.union(that.retracted))
-
-    def withRetracted(that: NotNullInfo): NotNullInfo =
-      NotNullInfo(this.asserted, this.retracted.union(that.retracted))
+      val newAsserted =
+        if this.asserted == null then that.asserted
+        else if that.asserted == null then this.asserted
+        else this.asserted.intersect(that.asserted)
+      val newRetracted = this.retracted.union(that.retracted)
+      NotNullInfo(newAsserted, newRetracted)
+  end NotNullInfo
 
   object NotNullInfo:
     val empty = new NotNullInfo(Set(), Set())
-    def apply(asserted: Set[TermRef], retracted: Set[TermRef]): NotNullInfo =
-      if asserted.isEmpty && retracted.isEmpty then empty
+    def apply(asserted: Set[TermRef] | Null, retracted: Set[TermRef]): NotNullInfo =
+      if asserted != null && asserted.isEmpty && retracted.isEmpty then empty
       else new NotNullInfo(asserted, retracted)
   end NotNullInfo
 
@@ -227,7 +235,7 @@ object Nullables:
     */
     @tailrec def impliesNotNull(ref: TermRef): Boolean = infos match
       case info :: infos1 =>
-        if info.asserted.contains(ref) then true
+        if info.asserted != null && info.asserted.contains(ref) then true
         else if info.retracted.contains(ref) then false
         else infos1.impliesNotNull(ref)
       case _ =>
@@ -243,7 +251,9 @@ object Nullables:
     /** 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)))
+        (ms, info) => ms.union(
+                        if info.asserted == null then Set.empty
+                        else info.asserted.filter(_.symbol.is(Mutable)))
       infos.extendWith(NotNullInfo(Set(), mutables))
 
   end extension
@@ -516,7 +526,10 @@ object Nullables:
       && assignmentSpans.getOrElse(sym.span.start, Nil).exists(whileSpan.contains(_))
       && ctx.notNullInfos.impliesNotNull(ref)
 
-    val retractedVars = ctx.notNullInfos.flatMap(_.asserted.filter(isRetracted)).toSet
+    val retractedVars = ctx.notNullInfos.flatMap(info =>
+      if info.asserted == null then Set.empty
+      else info.asserted.filter(isRetracted)
+    ).toSet
     ctx.addNotNullInfo(NotNullInfo(Set(), retractedVars))
   end whileContext
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 392a4e18c454..5ec9dbbe28b9 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1551,13 +1551,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
     def thenPathInfo = cond1.notNullInfoIf(true).seq(result.thenp.notNullInfo)
     def elsePathInfo = cond1.notNullInfoIf(false).seq(result.elsep.notNullInfo)
-    result.withNotNullInfo(
-      if result.thenp.tpe.isNothingType then
-        elsePathInfo.withRetracted(thenPathInfo)
-      else if result.elsep.tpe.isNothingType then
-        thenPathInfo.withRetracted(elsePathInfo)
-      else thenPathInfo.alt(elsePathInfo)
-    )
+    result.withNotNullInfo(thenPathInfo.alt(elsePathInfo))
   end typedIf
 
   /** Decompose function prototype into a list of parameter prototypes and a result
@@ -2154,14 +2148,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   }
 
   private def notNullInfoFromCases(initInfo: NotNullInfo, cases: List[CaseDef])(using Context): NotNullInfo =
-    var nnInfo = initInfo
     if cases.nonEmpty then
-      val (nothingCases, normalCases) = cases.partition(_.body.tpe.isNothingType)
-      nnInfo = nothingCases.foldLeft(nnInfo):
-        (nni, c) => nni.withRetracted(c.notNullInfo)
-      if normalCases.nonEmpty then
-        nnInfo = nnInfo.seq(normalCases.map(_.notNullInfo).reduce(_.alt(_)))
-    nnInfo
+      initInfo.seq(cases.map(_.notNullInfo).reduce(_.alt(_)))
+    else initInfo
 
   def typedCases(cases: List[untpd.CaseDef], sel: Tree, wideSelType0: Type, pt: Type)(using Context): List[CaseDef] =
     var caseCtx = ctx
@@ -2251,7 +2240,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   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))
+    assignType(cpy.Labeled(tree)(bind1, expr1)).withNotNullInfo(expr1.notNullInfo.retractedInfo)
   }
 
   /** Type a case of a type match */
@@ -2301,7 +2290,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                             // Hence no adaptation is possible, and we assume WildcardType as prototype.
         (from, proto)
     val expr1 = typedExpr(tree.expr orElse untpd.syntheticUnitLiteral.withSpan(tree.span), proto)
-    assignType(cpy.Return(tree)(expr1, from))
+    assignType(cpy.Return(tree)(expr1, from)).withNotNullInfo(expr1.notNullInfo.terminatedInfo)
   end typedReturn
 
   def typedWhileDo(tree: untpd.WhileDo)(using Context): Tree =
@@ -2388,15 +2377,15 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   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)
+    var 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` annotation.
-      Typed(res,
+      res = Typed(res,
         TypeTree(
           AnnotatedType(res.tpe,
             Annotation(defn.RequiresCapabilityAnnot, cap, tree.span))))
-    else res
+    res.withNotNullInfo(expr1.notNullInfo.terminatedInfo)
 
   def typedSeqLiteral(tree: untpd.SeqLiteral, pt: Type)(using Context): SeqLiteral = {
     val elemProto = pt.stripNull().elemType match {

From 158af7deed473826b5d16ade6b9472fd89948b6d Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Fri, 6 Dec 2024 16:59:32 +0100
Subject: [PATCH 281/306] Fix deep NotNullInfo

---
 .../dotty/tools/dotc/typer/Applications.scala |  7 ++-
 .../dotty/tools/dotc/typer/Nullables.scala    | 54 +++++++++++++------
 .../src/dotty/tools/dotc/typer/Typer.scala    |  1 -
 tests/explicit-nulls/neg/i21619.scala         | 15 +++++-
 4 files changed, 57 insertions(+), 20 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index 41e48f7595dc..96c38bcc80af 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -1134,7 +1134,7 @@ trait Applications extends Compatibility {
             case _ => ()
         else ()
 
-      fun1.tpe match {
+      val result = fun1.tpe match {
         case err: ErrorType => cpy.Apply(tree)(fun1, proto.typedArgs()).withType(err)
         case TryDynamicCallType =>
           val isInsertedApply = fun1 match {
@@ -1208,6 +1208,11 @@ trait Applications extends Compatibility {
                   else tryWithImplicitOnQualifier(fun1, proto).getOrElse(fail))
             }
       }
+
+      if result.tpe.isNothingType then
+        val nnInfo = result.notNullInfo
+        result.withNotNullInfo(nnInfo.terminatedInfo)
+      else result
     }
 
     /** Convert expression like
diff --git a/compiler/src/dotty/tools/dotc/typer/Nullables.scala b/compiler/src/dotty/tools/dotc/typer/Nullables.scala
index 30c65771d9c2..2193866893f6 100644
--- a/compiler/src/dotty/tools/dotc/typer/Nullables.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Nullables.scala
@@ -319,11 +319,29 @@ object Nullables:
       if !info.isEmpty then tree.putAttachment(NNInfo, info)
       tree
 
+    /* Collect the nullability info from parts of `tree` */
+    def collectNotNullInfo(using Context): NotNullInfo = tree match
+      case Typed(expr, _) =>
+        expr.notNullInfo
+      case Apply(fn, args) =>
+        val argsInfo = args.map(_.notNullInfo)
+        val fnInfo = fn.notNullInfo
+        argsInfo.foldLeft(fnInfo)(_ seq _)
+      case TypeApply(fn, _) =>
+        fn.notNullInfo
+      case _ =>
+        // Other cases are handled specially in typer.
+        NotNullInfo.empty
+
     /* The nullability info of `tree` */
     def notNullInfo(using Context): NotNullInfo =
-      stripInlined(tree).getAttachment(NNInfo) match
+      val tree1 = stripInlined(tree)
+      tree1.getAttachment(NNInfo) match
         case Some(info) if !ctx.erasedTypes => info
-        case _ => NotNullInfo.empty
+        case _ =>
+          val nnInfo = tree1.collectNotNullInfo
+          tree1.withNotNullInfo(nnInfo)
+          nnInfo
 
     /* The nullability info of `tree`, assuming it is a condition that evaluates to `c` */
     def notNullInfoIf(c: Boolean)(using Context): NotNullInfo =
@@ -404,21 +422,23 @@ object Nullables:
   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
+    def computeAssignNullable()(using Context): tree.type =
+      var nnInfo = tree.rhs.notNullInfo
+      tree.lhs match
+        case TrackedRef(ref) if ctx.explicitNulls && ref.isNullableUnion =>
+          nnInfo = nnInfo.seq:
+            val rhstp = tree.rhs.typeOpt
+            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.
+              NotNullInfo(Set(), Set(ref))
+            else
+              // If the initial type is nullable and the assigned value is non-null,
+              // we add it to the NotNull.
+              NotNullInfo(Set(ref), Set())
+        case _ =>
+      tree.withNotNullInfo(nnInfo)
   end extension
 
   private val analyzedOps = Set(nme.EQ, nme.NE, nme.eq, nme.ne, nme.ZAND, nme.ZOR, nme.UNARY_!)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 5ec9dbbe28b9..1e461a5e1cb7 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1201,7 +1201,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             untpd.unsplice(tree.expr).putAttachment(AscribedToUnit, ())
           typed(tree.expr, underlyingTreeTpe.tpe.widenSkolem)
       assignType(cpy.Typed(tree)(expr1, tpt), underlyingTreeTpe)
-        .withNotNullInfo(expr1.notNullInfo)
     }
 
     if (untpd.isWildcardStarArg(tree)) {
diff --git a/tests/explicit-nulls/neg/i21619.scala b/tests/explicit-nulls/neg/i21619.scala
index 244f993fd4e1..d7af27e3fe64 100644
--- a/tests/explicit-nulls/neg/i21619.scala
+++ b/tests/explicit-nulls/neg/i21619.scala
@@ -76,4 +76,17 @@ def test5: Unit =
   catch
     case _ =>
   val z1: String = x.replace("", "") // error
-  val z2: String = y.replace("", "")
\ No newline at end of file
+  val z2: String = y.replace("", "")
+
+def test6 = {
+  var x: String | Null = ""
+  var y: String = ""
+  x = ""
+  y = if (false) x else 1 match {
+    case _ => {
+      x = null
+      y
+    }
+  }
+  x.replace("", "") // error
+}
\ No newline at end of file

From 00430c042a9031059aefe638caba7c7e2e8c49f5 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Sat, 7 Dec 2024 04:28:02 +0100
Subject: [PATCH 282/306] Treat asserted set of terminated NotNullInfo as
 universal set; fix test

---
 .../src/dotty/tools/dotc/core/Contexts.scala  |  6 ++---
 .../dotty/tools/dotc/typer/Nullables.scala    | 22 ++++++++++---------
 .../src/dotty/tools/dotc/typer/Typer.scala    |  2 ++
 .../pos/after-termination.scala               | 17 ++++++++++++++
 .../unsafe-common/unsafe-overload.scala       | 12 +++++-----
 5 files changed, 40 insertions(+), 19 deletions(-)
 create mode 100644 tests/explicit-nulls/pos/after-termination.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Contexts.scala b/compiler/src/dotty/tools/dotc/core/Contexts.scala
index d69c7408d0b1..7f5779bb6127 100644
--- a/compiler/src/dotty/tools/dotc/core/Contexts.scala
+++ b/compiler/src/dotty/tools/dotc/core/Contexts.scala
@@ -777,13 +777,13 @@ object Contexts {
 
   extension (c: Context)
     def addNotNullInfo(info: NotNullInfo) =
-      c.withNotNullInfos(c.notNullInfos.extendWith(info))
+      if c.explicitNulls then c.withNotNullInfos(c.notNullInfos.extendWith(info)) else c
 
     def addNotNullRefs(refs: Set[TermRef]) =
-      c.addNotNullInfo(NotNullInfo(refs, Set()))
+      if c.explicitNulls then c.addNotNullInfo(NotNullInfo(refs, Set())) else c
 
     def withNotNullInfos(infos: List[NotNullInfo]): Context =
-      if c.notNullInfos eq infos then c else c.fresh.setNotNullInfos(infos)
+      if !c.explicitNulls || (c.notNullInfos eq infos) then c else c.fresh.setNotNullInfos(infos)
 
     def relaxedOverrideContext: Context =
       c.withModeBits(c.mode &~ Mode.SafeNulls | Mode.RelaxedOverriding)
diff --git a/compiler/src/dotty/tools/dotc/typer/Nullables.scala b/compiler/src/dotty/tools/dotc/typer/Nullables.scala
index 2193866893f6..310ca999f4c5 100644
--- a/compiler/src/dotty/tools/dotc/typer/Nullables.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Nullables.scala
@@ -235,7 +235,7 @@ object Nullables:
     */
     @tailrec def impliesNotNull(ref: TermRef): Boolean = infos match
       case info :: infos1 =>
-        if info.asserted != null && info.asserted.contains(ref) then true
+        if info.asserted == null || info.asserted.contains(ref) then true
         else if info.retracted.contains(ref) then false
         else infos1.impliesNotNull(ref)
       case _ =>
@@ -315,8 +315,8 @@ object Nullables:
   extension (tree: Tree)
 
     /* The `tree` with added nullability attachment */
-    def withNotNullInfo(info: NotNullInfo): tree.type =
-      if !info.isEmpty then tree.putAttachment(NNInfo, info)
+    def withNotNullInfo(info: NotNullInfo)(using Context): tree.type =
+      if ctx.explicitNulls && !info.isEmpty then tree.putAttachment(NNInfo, info)
       tree
 
     /* Collect the nullability info from parts of `tree` */
@@ -335,13 +335,15 @@ object Nullables:
 
     /* The nullability info of `tree` */
     def notNullInfo(using Context): NotNullInfo =
-      val tree1 = stripInlined(tree)
-      tree1.getAttachment(NNInfo) match
-        case Some(info) if !ctx.erasedTypes => info
-        case _ =>
-          val nnInfo = tree1.collectNotNullInfo
-          tree1.withNotNullInfo(nnInfo)
-          nnInfo
+      if !ctx.explicitNulls then NotNullInfo.empty
+      else
+        val tree1 = stripInlined(tree)
+        tree1.getAttachment(NNInfo) match
+          case Some(info) if !ctx.erasedTypes => info
+          case _ =>
+            val nnInfo = tree1.collectNotNullInfo
+            tree1.withNotNullInfo(nnInfo)
+            nnInfo
 
     /* The nullability info of `tree`, assuming it is a condition that evaluates to `c` */
     def notNullInfoIf(c: Boolean)(using Context): NotNullInfo =
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 1e461a5e1cb7..cea47817bb88 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2849,6 +2849,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val vdef1 = assignType(cpy.ValDef(vdef)(name, tpt1, rhs1), sym)
     postProcessInfo(vdef1, sym)
     vdef1.setDefTree
+    val nnInfo = rhs1.notNullInfo
+    vdef1.withNotNullInfo(if sym.is(Lazy) then nnInfo.retractedInfo else nnInfo)
   }
 
   private def retractDefDef(sym: Symbol)(using Context): Tree =
diff --git a/tests/explicit-nulls/pos/after-termination.scala b/tests/explicit-nulls/pos/after-termination.scala
new file mode 100644
index 000000000000..00a57e371281
--- /dev/null
+++ b/tests/explicit-nulls/pos/after-termination.scala
@@ -0,0 +1,17 @@
+class C(val x: Int, val next: C | Null)
+
+def test1(x: String | Null, c: C | Null): Int =
+  return 0
+  // We know that the following code is unreachable,
+  // so we can treat `x`, `c`, and any variable/path non-nullable.
+  x.length + c.next.x
+
+def test2(x: String | Null, c: C | Null): Int =
+  throw new Exception()
+  x.length + c.next.x
+
+def fail(): Nothing = ???
+
+def test3(x: String | Null, c: C | Null): Int =
+  fail()
+  x.length + c.next.x
diff --git a/tests/explicit-nulls/unsafe-common/unsafe-overload.scala b/tests/explicit-nulls/unsafe-common/unsafe-overload.scala
index e7e551f1bda1..21af320806d8 100644
--- a/tests/explicit-nulls/unsafe-common/unsafe-overload.scala
+++ b/tests/explicit-nulls/unsafe-common/unsafe-overload.scala
@@ -16,8 +16,8 @@ class S {
   val o: O = ???
 
   locally {
-    def h1(hh: String => String) = ???
-    def h2(hh: Array[String] => Array[String]) = ???
+    def h1(hh: String => String): Unit = ???
+    def h2(hh: Array[String] => Array[String]): Unit = ???
     def f1(x: String | Null): String | Null = ???
     def f2(x: Array[String | Null]):  Array[String | Null] = ???
 
@@ -29,10 +29,10 @@ class S {
   }
 
   locally {
-    def h1(hh: String | Null => String | Null) = ???
-    def h2(hh: Array[String | Null] => Array[String | Null]) = ???
+    def h1(hh: String | Null => String | Null): Unit = ???
+    def h2(hh: Array[String | Null] => Array[String | Null]): Unit = ???
     def g1(x: String): String = ???
-    def g2(x: Array[String]):  Array[String] = ???
+    def g2(x: Array[String]): Array[String] = ???
 
     h1(g1) // error
     h1(o.g) // error
@@ -51,7 +51,7 @@ class S {
 
   locally {
     def g1(x: String): String = ???
-    def g2(x: Array[String]):  Array[String] = ???
+    def g2(x: Array[String]): Array[String] = ???
 
     o.i(g1) // error
     o.i(g2) // error

From 200c038a818ed41d8a07a18b540abd0748a99f12 Mon Sep 17 00:00:00 2001
From: noti0na1 <noti0na1@users.noreply.github.com>
Date: Tue, 10 Dec 2024 12:24:34 +0100
Subject: [PATCH 283/306] Comment on the empty cases in notNullInfoFromCases.

---
 compiler/src/dotty/tools/dotc/typer/Typer.scala | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index cea47817bb88..2c513a41a039 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2147,9 +2147,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   }
 
   private def notNullInfoFromCases(initInfo: NotNullInfo, cases: List[CaseDef])(using Context): NotNullInfo =
-    if cases.nonEmpty then
-      initInfo.seq(cases.map(_.notNullInfo).reduce(_.alt(_)))
-    else initInfo
+    if cases.isEmpty then
+      // Empty cases is not allowed for match tree in the source code,
+      // but it can be generated by inlining: `tests/pos/i19198.scala`.
+      initInfo
+    else cases.map(_.notNullInfo).reduce(_.alt(_))
 
   def typedCases(cases: List[untpd.CaseDef], sel: Tree, wideSelType0: Type, pt: Type)(using Context): List[CaseDef] =
     var caseCtx = ctx

From ecf9be9532b9bd4729f4a6ec7358ef59ff96246a Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Tue, 10 Dec 2024 16:46:19 +0100
Subject: [PATCH 284/306] Fix Chocolatey publish workflow

---
 .github/workflows/publish-chocolatey.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/publish-chocolatey.yml b/.github/workflows/publish-chocolatey.yml
index 3b31728a50ba..88a8a7913188 100644
--- a/.github/workflows/publish-chocolatey.yml
+++ b/.github/workflows/publish-chocolatey.yml
@@ -35,5 +35,5 @@ jobs:
         with:
           name: scala.nupkg
       - name: Publish the package to Chocolatey
-        run: choco push scala.nupkg --source https://push.chocolatey.org/ --api-key ${{ secrets.API-KEY }}
+        run: choco push scala.${{inputs.version}}.nupkg --source https://push.chocolatey.org/ --api-key ${{ secrets.API-KEY }}
         
\ No newline at end of file

From 70cc1a19da85f502fc58c8f0ed4fbe6ff9444e7d Mon Sep 17 00:00:00 2001
From: Rui Chen <rui@chenrui.dev>
Date: Tue, 10 Dec 2024 15:38:45 -0500
Subject: [PATCH 285/306] fix: update `scala-cli.jar` path

Signed-off-by: Rui Chen <rui@chenrui.dev>
---
 dist/libexec/cli-common-platform     | 2 +-
 dist/libexec/cli-common-platform.bat | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/dist/libexec/cli-common-platform b/dist/libexec/cli-common-platform
index a5906e882bb4..e56f5221dbf2 100644
--- a/dist/libexec/cli-common-platform
+++ b/dist/libexec/cli-common-platform
@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
 
-SCALA_CLI_CMD_BASH=("\"$JAVACMD\"" "-jar \"$PROG_HOME/bin/scala-cli.jar\"")
+SCALA_CLI_CMD_BASH=("\"$JAVACMD\"" "-jar \"$PROG_HOME/libexec/scala-cli.jar\"")
diff --git a/dist/libexec/cli-common-platform.bat b/dist/libexec/cli-common-platform.bat
index 99103266c1d9..45b09f3460e6 100644
--- a/dist/libexec/cli-common-platform.bat
+++ b/dist/libexec/cli-common-platform.bat
@@ -2,4 +2,4 @@
 
 @rem we need to escape % in the java command path, for some reason this doesnt work in common.bat
 set "_JAVACMD=!_JAVACMD:%%=%%%%!"
-set SCALA_CLI_CMD_WIN="%_JAVACMD%" "-jar" "%_PROG_HOME%\bin\scala-cli.jar"
\ No newline at end of file
+set SCALA_CLI_CMD_WIN="%_JAVACMD%" "-jar" "%_PROG_HOME%\libexec\scala-cli.jar"

From 004cfc5ed76ea34245ca30c9cc3872e86f9e6d5e Mon Sep 17 00:00:00 2001
From: Eugene Yokota <eed3si9n@gmail.com>
Date: Wed, 11 Dec 2024 01:32:40 -0500
Subject: [PATCH 286/306] refactor: improve Given search preference warning

**Problem**
It wasn't clear what action users was suppose to take to suppress
the new-from-3.6 Given search preference warning.

**Solution**
1. This refactors the code to give the warning an error code E205.
2. In case of warnings, tell the user to choose -source 3.5 vs 3.7,
   or use nowarn annotation.
---
 .../tools/dotc/reporting/ErrorMessageID.scala |  1 +
 .../dotty/tools/dotc/reporting/messages.scala | 38 +++++++++++++++++++
 .../dotty/tools/dotc/typer/Implicits.scala    | 22 ++---------
 tests/neg/given-triangle.check                |  6 +--
 tests/warn/i21036a.check                      | 11 ++++--
 tests/warn/i21036b.check                      |  9 +++--
 tests/warn/i21036c.scala                      |  7 ++++
 7 files changed, 66 insertions(+), 28 deletions(-)
 create mode 100644 tests/warn/i21036c.scala

diff --git a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
index 2c3774b59a9a..d3467fe70c52 100644
--- a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
@@ -218,6 +218,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case QuotedTypeMissingID // errorNumber: 202
   case DeprecatedAssignmentSyntaxID // errorNumber: 203
   case DeprecatedInfixNamedArgumentSyntaxID // errorNumber: 204
+  case GivenSearchPriorityID // errorNumber: 205
 
   def errorNumber = ordinal - 1
 
diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index b396aa62f599..75aa553827f2 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -3361,3 +3361,41 @@ class DeprecatedInfixNamedArgumentSyntax()(using Context) extends SyntaxMsg(Depr
         + Message.rewriteNotice("This", version = SourceVersion.`3.6-migration`)
 
   def explain(using Context) = ""
+
+class GivenSearchPriorityWarning(
+    pt: Type,
+    cmp: Int,
+    prev: Int,
+    winner: TermRef,
+    loser: TermRef,
+    isLastOldVersion: Boolean
+)(using Context) extends Message(GivenSearchPriorityID):
+  def kind = MessageKind.PotentialIssue
+  def choice(nth: String, c: Int) =
+    if c == 0 then "none - it's ambiguous"
+    else s"the $nth alternative"
+  val (change, whichChoice) =
+    if isLastOldVersion
+    then ("will change in the future release", "Current choice ")
+    else ("has changed",                       "Previous choice")
+  def warningMessage: String =
+    i"""Given search preference for $pt between alternatives
+       |  ${loser}
+       |and
+       |  ${winner}
+       |$change.
+       |$whichChoice       : ${choice("first", prev)}
+       |Choice from Scala 3.7 : ${choice("second", cmp)}"""
+  def migrationHints: String =
+    i"""Suppress this warning by choosing -source 3.5, -source 3.7, or
+       |by using @annotation.nowarn("id=205")"""
+  def ambiguousNote: String =
+    i"""
+       |
+       |Note: $warningMessage"""
+  def msg(using Context) =
+    i"""$warningMessage
+       |
+       |$migrationHints"""
+
+  def explain(using Context) = ""
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 228206d8fb1e..193cc443b4ae 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -549,10 +549,10 @@ object Implicits:
   /** An ambiguous implicits failure */
   class AmbiguousImplicits(val alt1: SearchSuccess, val alt2: SearchSuccess, val expectedType: Type, val argument: Tree, val nested: Boolean = false) extends SearchFailureType:
 
-    private[Implicits] var priorityChangeWarnings: List[Message] = Nil
+    private[Implicits] var priorityChangeWarnings: List[GivenSearchPriorityWarning] = Nil
 
     def priorityChangeWarningNote(using Context): String =
-      priorityChangeWarnings.map(msg => s"\n\nNote: $msg").mkString
+      priorityChangeWarnings.map(_.ambiguousNote).mkString
 
     def msg(using Context): Message =
       var str1 = err.refStr(alt1.ref)
@@ -1312,7 +1312,7 @@ trait Implicits:
       // A map that associates a priority change warning (between -source 3.6 and 3.7)
       // with the candidate refs mentioned in the warning. We report the associated
       // message if one of the critical candidates is part of the result of the implicit search.
-      val priorityChangeWarnings = mutable.ListBuffer[(/*critical:*/ List[TermRef], Message)]()
+      val priorityChangeWarnings = mutable.ListBuffer[(/*critical:*/ List[TermRef], GivenSearchPriorityWarning)]()
 
       val sv = Feature.sourceVersion
       val isLastOldVersion = sv.stable == SourceVersion.`3.6`
@@ -1353,21 +1353,7 @@ trait Implicits:
                     cmp match
                       case 1 => (alt2, alt1)
                       case -1 => (alt1, alt2)
-              def choice(nth: String, c: Int) =
-                if c == 0 then  "none - it's ambiguous"
-                else s"the $nth alternative"
-              val (change, whichChoice) =
-                if isLastOldVersion
-                then ("will change", "Current choice ")
-                else ("has changed", "Previous choice")
-              val msg =
-                em"""Given search preference for $pt between alternatives
-                    |  ${loser.ref}
-                    |and
-                    |  ${winner.ref}
-                    |$change.
-                    |$whichChoice          : ${choice("first", prev)}
-                    |New choice from Scala 3.7: ${choice("second", cmp)}"""
+              val msg = GivenSearchPriorityWarning(pt, cmp, prev, winner.ref, loser.ref, isLastOldVersion)
               val critical = alt1.ref :: alt2.ref :: Nil
               priorityChangeWarnings += ((critical, msg))
               if isLastOldVersion then prev else cmp
diff --git a/tests/neg/given-triangle.check b/tests/neg/given-triangle.check
index f366c18e78f0..8a05ed4b3129 100644
--- a/tests/neg/given-triangle.check
+++ b/tests/neg/given-triangle.check
@@ -7,6 +7,6 @@
    |  (given_B : B)
    |and
    |  (given_A : A)
-   |will change.
-   |Current choice           : the first alternative
-   |New choice from Scala 3.7: the second alternative
+   |will change in the future release.
+   |Current choice        : the first alternative
+   |Choice from Scala 3.7 : the second alternative
diff --git a/tests/warn/i21036a.check b/tests/warn/i21036a.check
index 63d611a6e246..6ce5b94d123f 100644
--- a/tests/warn/i21036a.check
+++ b/tests/warn/i21036a.check
@@ -1,10 +1,13 @@
--- Warning: tests/warn/i21036a.scala:7:17 ------------------------------------------------------------------------------
+-- [E205] Potential Issue Warning: tests/warn/i21036a.scala:7:17 -------------------------------------------------------
 7 |val y = summon[A] // warn
   |                 ^
   |                 Given search preference for A between alternatives
   |                   (b : B)
   |                 and
   |                   (a : A)
-  |                 will change.
-  |                 Current choice           : the first alternative
-  |                 New choice from Scala 3.7: the second alternative
+  |                 will change in the future release.
+  |                 Current choice        : the first alternative
+  |                 Choice from Scala 3.7 : the second alternative
+  |
+  |                 Suppress this warning by choosing -source 3.5, -source 3.7, or
+  |                 by using @annotation.nowarn("id=205")
diff --git a/tests/warn/i21036b.check b/tests/warn/i21036b.check
index dfa19a0e9bb1..da0639438c86 100644
--- a/tests/warn/i21036b.check
+++ b/tests/warn/i21036b.check
@@ -1,4 +1,4 @@
--- Warning: tests/warn/i21036b.scala:7:17 ------------------------------------------------------------------------------
+-- [E205] Potential Issue Warning: tests/warn/i21036b.scala:7:17 -------------------------------------------------------
 7 |val y = summon[A] // warn
   |                 ^
   |                 Given search preference for A between alternatives
@@ -6,5 +6,8 @@
   |                 and
   |                   (a : A)
   |                 has changed.
-  |                 Previous choice          : the first alternative
-  |                 New choice from Scala 3.7: the second alternative
+  |                 Previous choice       : the first alternative
+  |                 Choice from Scala 3.7 : the second alternative
+  |
+  |                 Suppress this warning by choosing -source 3.5, -source 3.7, or
+  |                 by using @annotation.nowarn("id=205")
diff --git a/tests/warn/i21036c.scala b/tests/warn/i21036c.scala
new file mode 100644
index 000000000000..4015cc8a84bb
--- /dev/null
+++ b/tests/warn/i21036c.scala
@@ -0,0 +1,7 @@
+trait A
+trait B extends A
+given b: B = ???
+given a: A = ???
+
+@annotation.nowarn("id=205")
+val y = summon[A] // don't warn
\ No newline at end of file

From 74417916fd97990a77c80462758ab240e52aa586 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Wed, 11 Dec 2024 17:54:57 +0100
Subject: [PATCH 287/306] Update reference, MiMa previous version and sync
 TASTy version (#22187)

* Update reference version to 3.6.3-RC1 (from 3.6.0)
* Update mima previous binary verison to 3.6.2 (instead of unofficial
3.6.1)
* Set TASTy version to `28.7-experimental-1` - it should have been set
when branching of 3.6.3.
* We now document better how and when tasty version should be set
* Add additional runtime test to ensure we don't emit invalid TASTy
version during Release / NIGHTLY releases and the expected version set
in build matches version defined in TastyFormat
---
 project/Build.scala                           | 63 +++++++++++++++++--
 tasty/src/dotty/tools/tasty/TastyFormat.scala |  2 +-
 .../tools/tasty/BuildTastyVersionTest.scala   | 26 ++++++++
 3 files changed, 85 insertions(+), 6 deletions(-)
 create mode 100644 tasty/test/dotty/tools/tasty/BuildTastyVersionTest.scala

diff --git a/project/Build.scala b/project/Build.scala
index f36171aabbcd..db3f149cbab6 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -93,11 +93,12 @@ object Build {
 
   /** Version of the Scala compiler used to build the artifacts.
    *  Reference version should track the latest version pushed to Maven:
-   *  - In main branch it should be the last RC version (using experimental TASTy required for non-bootstrapped tests)
+   *  - In main branch it should be the last RC version
    *  - In release branch it should be the last stable release
-   *  3.6.0-RC1 was released as 3.6.0 - it's having and experimental TASTy version
+   * 
+   *  Warning: Change of this variable needs to be consulted with `expectedTastyVersion` 
    */
-  val referenceVersion = "3.6.0"
+  val referenceVersion = "3.6.3-RC1"
 
   /** Version of the Scala compiler targeted in the current release cycle
    *  Contains a version without RC/SNAPSHOT/NIGHTLY specific suffixes
@@ -105,6 +106,8 @@ object Build {
    *
    *  Should only be referred from `dottyVersion` or settings/tasks requiring simplified version string,
    *  eg. `compatMode` or Windows native distribution version.
+   * 
+   *  Warning: Change of this variable might require updating `expectedTastyVersion` 
    */
   val developedVersion = "3.6.4"
 
@@ -116,6 +119,25 @@ object Build {
    *  During final, stable release is set exactly to `developedVersion`.
   */
   val baseVersion = s"$developedVersion-RC1"
+  
+  /** The version of TASTY that should be emitted, checked in runtime test 
+   *  For defails on how TASTY version should be set see related discussions: 
+   *    - https://github.com/scala/scala3/issues/13447#issuecomment-912447107
+   *    - https://github.com/scala/scala3/issues/14306#issuecomment-1069333516
+   *    - https://github.com/scala/scala3/pull/19321
+   *   
+   *  Simplified rules, given 3.$minor.$patch = $developedVersion
+   *    - Major version is always 28
+   *    - TASTY minor version:
+   *      - in main (NIGHTLY): {if $patch == 0 then $minor else ${minor + 1}}
+   *      - in release branch is always equal to $minor
+   *    - TASTY experimental version:
+   *      - in main (NIGHTLY) is always experimental
+   *      - in release candidate branch is experimental if {patch == 0}
+   *      - in stable release is always non-experimetnal
+   */
+  val expectedTastyVersion = "28.7-experimental-1"
+  checkReleasedTastyVersion()
 
   /** Final version of Scala compiler, controlled by environment variables. */
   val dottyVersion = {
@@ -149,9 +171,9 @@ object Build {
    *  For a developedVersion `3.M.P` the mimaPreviousDottyVersion should be set to:
    *   - `3.M.0`     if `P > 0`
    *   - `3.(M-1).0` if `P = 0`
-   *  3.6.1 is an exception from this rule - 3.6.0 was a broken release
+   *  3.6.2 is an exception from this rule - 3.6.0 was a broken release, 3.6.1 was hotfix (unstable) release
    */
-  val mimaPreviousDottyVersion = "3.6.1"
+  val mimaPreviousDottyVersion = "3.6.2"
 
   /** LTS version against which we check binary compatibility.
    *
@@ -2424,6 +2446,9 @@ object Build {
       settings(disableDocSetting).
       settings(
         versionScheme := Some("semver-spec"),
+        Test / envVars ++= Map(
+          "EXPECTED_TASTY_VERSION" -> expectedTastyVersion,
+        ),
         if (mode == Bootstrapped) Def.settings(
           commonMiMaSettings,
           mimaForwardIssueFilters := MiMaFilters.TastyCore.ForwardsBreakingChanges,
@@ -2473,6 +2498,34 @@ object Build {
       case Bootstrapped => commonBootstrappedSettings
     })
   }
+  
+  /* Tests TASTy version invariants during NIGHLY, RC or Stable releases */
+  def checkReleasedTastyVersion(): Unit = {
+    lazy val (scalaMinor, scalaPatch, scalaIsRC) = baseVersion.split("\\.|-").take(4) match {
+      case Array("3", minor, patch)    => (minor.toInt, patch.toInt, false)
+      case Array("3", minor, patch, _) => (minor.toInt, patch.toInt, true)
+      case other => sys.error(s"Invalid Scala base version string: $baseVersion")
+    }
+    lazy val (tastyMinor, tastyIsExperimental) = expectedTastyVersion.split("\\.|-").take(4) match {
+      case Array("28", minor)                    => (minor.toInt, false)
+      case Array("28", minor, "experimental", _) => (minor.toInt, true)
+      case other => sys.error(s"Invalid TASTy version string: $expectedTastyVersion")
+    }
+     
+    if(isNightly) {
+      assert(tastyIsExperimental, "TASTY needs to be experimental in nightly builds")
+      val expectedTastyMinor = if(scalaPatch == 0) scalaMinor else scalaMinor + 1
+      assert(tastyMinor == expectedTastyMinor, "Invalid TASTy minor version")
+    }
+    
+    if(isRelease) {
+      assert(scalaMinor == tastyMinor, "Minor versions of TASTY vesion and Scala version should match in release builds")
+      if (scalaIsRC && scalaPatch == 0)
+        assert(tastyIsExperimental, "TASTy should be experimental when releasing a new minor version RC")
+      else
+        assert(!tastyIsExperimental, "Stable version cannot use experimental TASTY") 
+    }
+  }
 }
 
 object ScaladocConfigs {
diff --git a/tasty/src/dotty/tools/tasty/TastyFormat.scala b/tasty/src/dotty/tools/tasty/TastyFormat.scala
index 8f5f9d57a8a5..8ff590fefec5 100644
--- a/tasty/src/dotty/tools/tasty/TastyFormat.scala
+++ b/tasty/src/dotty/tools/tasty/TastyFormat.scala
@@ -324,7 +324,7 @@ object TastyFormat {
    *  compatibility, but remains backwards compatible, with all
    *  preceding `MinorVersion`.
    */
-  final val MinorVersion: Int = 6
+  final val MinorVersion: Int = 7
 
   /** Natural Number. The `ExperimentalVersion` allows for
    *  experimentation with changes to TASTy without committing
diff --git a/tasty/test/dotty/tools/tasty/BuildTastyVersionTest.scala b/tasty/test/dotty/tools/tasty/BuildTastyVersionTest.scala
new file mode 100644
index 000000000000..d2e62e1f9eb0
--- /dev/null
+++ b/tasty/test/dotty/tools/tasty/BuildTastyVersionTest.scala
@@ -0,0 +1,26 @@
+package dotty.tools.tasty
+
+import org.junit.Assert._
+import org.junit.Test
+
+import TastyBuffer._
+
+// Tests ensuring TASTY version emitted by compiler is matching expected TASTY version
+class BuildTastyVersionTest {
+  
+  val CurrentTastyVersion = TastyVersion(TastyFormat.MajorVersion, TastyFormat.MinorVersion, TastyFormat.ExperimentalVersion)
+  
+  // Needs to be defined in build Test/envVars
+  val ExpectedTastyVersionEnvVar = "EXPECTED_TASTY_VERSION"
+  
+  @Test def testBuildTastyVersion(): Unit = {
+    val expectedVersion = sys.env.get(ExpectedTastyVersionEnvVar)
+      .getOrElse(fail(s"Env variable $ExpectedTastyVersionEnvVar not defined"))
+      .match {
+        case s"$major.$minor-experimental-$experimental" => TastyVersion(major.toInt, minor.toInt, experimental.toInt)
+        case s"$major.$minor" if minor.forall(_.isDigit) => TastyVersion(major.toInt, minor.toInt, 0)
+        case other => fail(s"Invalid TASTY version string: $other")
+      }
+    assertEquals(CurrentTastyVersion, expectedVersion)
+  }
+}

From 93ef8107c78d9a311f01716224130d7a7a5bd784 Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Thu, 12 Dec 2024 10:17:29 +0100
Subject: [PATCH 288/306] Remove tests/pos-with-compiler-cc from VSCode ignored
 files

---
 .vscode-template/settings.json | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/.vscode-template/settings.json b/.vscode-template/settings.json
index 257da27b118f..8cf2d29e3bae 100644
--- a/.vscode-template/settings.json
+++ b/.vscode-template/settings.json
@@ -9,7 +9,6 @@
     "**/*.class": true,
     "**/*.tasty": true,
     "**/target/": true,
-    "community-build/community-projects": true,
-    "tests/pos-with-compiler-cc/dotc/**/*.scala": true
+    "community-build/community-projects": true
   }
 }

From 5b3d82a41aafcaccab99bad95aa5a035a5dacabb Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Thu, 12 Dec 2024 15:21:33 +0100
Subject: [PATCH 289/306] Fix layout of released SDK archives, restore
 intermiediete top-level directory  (#22199)

Fixes #22194

Restores top-level directory `scala3-${version}` that is present in
artifacts published before Scala 3.6, removed during hotfix 3.6.1
release.
We now follow the [Well formed SDK archives
layout](https://github.com/sdkman/sdkman-cli/wiki/Well-formed-SDK-archives).
Removing the top-level directory even though at first glance looked like
an improvement was in fact introducing problems to multiple package
managers and build tools.
---
 .github/workflows/ci.yaml | 12 +++---------
 project/Build.scala       |  9 ++++++++-
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index a2006e16c7e8..cc1eb5d40d97 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -801,19 +801,13 @@ jobs:
             distDir="$3"
 
             # Build binaries
-            ./project/scripts/sbt "${sbtProject}/Universal/stage"
+            ./project/scripts/sbt "all ${sbtProject}/Universal/packageBin ${sbtProject}/Universal/packageZipTarball"
 
-            outputPath="${distDir}/target/universal/stage"
             artifactName="scala3-${{ env.RELEASE_TAG }}${distroSuffix}"
-            zipArchive="${artifactName}.zip"
-            tarGzArchive="${artifactName}.tar.gz"
-
-            cwd=$(pwd)
-            (cd $outputPath && zip -r ${zipArchive} . && mv ${zipArchive} "${cwd}/")
-            tar -czf ${tarGzArchive} -C "$outputPath" .
 
             # Caluclate SHA for each of archive files
-            for file in "${zipArchive}" "${tarGzArchive}"; do
+            for file in "${artifactName}.zip" "${artifactName}.tar.gz"; do
+              mv ${distDir}/target/universal/$file $file
               sha256sum "${file}" > "${file}.sha256"
             done
           }
diff --git a/project/Build.scala b/project/Build.scala
index db3f149cbab6..5aec4a4231a6 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -2257,7 +2257,14 @@ object Build {
     // ========
     Universal / stage := (Universal / stage).dependsOn(republish).value,
     Universal / packageBin := (Universal / packageBin).dependsOn(republish).value,
-    Universal / packageZipTarball := (Universal / packageZipTarball).dependsOn(republish).value,
+    Universal / packageZipTarball := (Universal / packageZipTarball).dependsOn(republish)
+      .map { archiveFile =>
+        // Rename .tgz to .tar.gz for consistency with previous versions
+        val renamedFile = archiveFile.getParentFile() / archiveFile.getName.replaceAll("\\.tgz$", ".tar.gz")
+        IO.move(archiveFile, renamedFile)
+        renamedFile
+      }
+      .value,
     // ========
     Universal / mappings ++= directory(dist.base / "bin"),
     Universal / mappings ++= directory(republishRepo.value / "maven2"),

From 6b9f9f797e78f32b135b7cc6bc941e10d073dd7f Mon Sep 17 00:00:00 2001
From: kasiaMarek <kasia@marek.net>
Date: Fri, 6 Dec 2024 18:37:53 +0100
Subject: [PATCH 290/306] Add type parameters derived from enum to default
 param getters of enum cases

---
 .../src/dotty/tools/dotc/ast/Desugar.scala    | 19 ++++++++++++-------
 tests/pos/i22137.scala                        |  5 +++++
 2 files changed, 17 insertions(+), 7 deletions(-)
 create mode 100644 tests/pos/i22137.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 56c153498f87..a95e64e24b85 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -694,15 +694,15 @@ object desugar {
     val originalTparams = constr1.leadingTypeParams
     val originalVparamss = asTermOnly(constr1.trailingParamss)
     lazy val derivedEnumParams = enumClass.typeParams.map(derivedTypeParamWithVariance)
-    val impliedTparams =
-      if (isEnumCase) {
+    val enumTParams =
+      if isEnumCase then
         val tparamReferenced = typeParamIsReferenced(
-            enumClass.typeParams, originalTparams, originalVparamss, parents)
-        if (originalTparams.isEmpty && (parents.isEmpty || tparamReferenced))
+          enumClass.typeParams, originalTparams, originalVparamss, parents)
+        if originalTparams.isEmpty && (parents.isEmpty || tparamReferenced) then
           derivedEnumParams.map(tdef => tdef.withFlags(tdef.mods.flags | PrivateLocal))
-        else originalTparams
-      }
-      else originalTparams
+        else Nil
+      else Nil
+    val impliedTparams = enumTParams ++ originalTparams
 
     if mods.is(Trait) then
       for vparams <- originalVparamss; vparam <- vparams do
@@ -735,6 +735,11 @@ object desugar {
         derived.withAnnotations(Nil)
 
     val constr = cpy.DefDef(constr1)(paramss = joinParams(constrTparams, constrVparamss))
+    if enumTParams.nonEmpty then
+      defaultGetters = defaultGetters.map:
+        case ddef: DefDef =>
+          val tParams = enumTParams.map(tparam => toMethParam(tparam, KeepAnnotations.All))
+          cpy.DefDef(ddef)(paramss = joinParams(tParams, ddef.trailingParamss))
 
     val (normalizedBody, enumCases, enumCompanionRef) = {
       // Add constructor type parameters and evidence implicit parameters
diff --git a/tests/pos/i22137.scala b/tests/pos/i22137.scala
new file mode 100644
index 000000000000..b52dd9171146
--- /dev/null
+++ b/tests/pos/i22137.scala
@@ -0,0 +1,5 @@
+enum Parser[+Value]:
+  case Success(value: Value, issues: Seq[Failure] = Seq.empty) extends Parser[Value]
+  case Failure(exception: Throwable)                           extends Parser[Nothing]
+
+val v = Parser.Success(1)
\ No newline at end of file

From 5e54eba09f9a3ff71031324b00ba577c7255039b Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 14 Dec 2024 18:07:24 +0100
Subject: [PATCH 291/306] Merge -Xno-decode-stacktraces with
 -Xno-enrich-error-messages

The two mean very similar things and -Xno-enrich-error-messages is better
documented, so more people will know to reach for it.

Keep -Xno-decode-stacktraces as an alias for -Xno-enrich-error-messages for now in order
to maintain backwards compatibility
---
 compiler/src/dotty/tools/dotc/config/ScalaSettings.scala   | 3 +--
 compiler/src/dotty/tools/dotc/core/TypeErrors.scala        | 2 +-
 compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala | 2 +-
 3 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
index 6ef33d24f8be..0cec6aeaa661 100644
--- a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
+++ b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
@@ -353,8 +353,7 @@ private sealed trait XSettings:
   val XreadComments: Setting[Boolean] = BooleanSetting(AdvancedSetting, "Xread-docs", "Read documentation from tasty.")
 
   /** Area-specific debug output */
-  val XnoDecodeStacktraces: Setting[Boolean] = BooleanSetting(AdvancedSetting, "Xno-decode-stacktraces", "Show raw StackOverflow stacktraces, instead of decoding them into triggering operations.")
-  val XnoEnrichErrorMessages: Setting[Boolean] = BooleanSetting(AdvancedSetting, "Xno-enrich-error-messages", "Show raw error messages, instead of enriching them with contextual information.")
+  val XnoEnrichErrorMessages: Setting[Boolean] = BooleanSetting(AdvancedSetting, "Xno-enrich-error-messages", "Show raw error messages, instead of enriching them with contextual information.", aliases = List("Xno-decode-stacktraces"))
   val XdebugMacros: Setting[Boolean] = BooleanSetting(AdvancedSetting, "Xdebug-macros", "Show debug info when quote pattern match fails")
 
   /** Pipeline compilation options */
diff --git a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala b/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
index 1c9696da67d1..40927dd3f40f 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
@@ -137,7 +137,7 @@ object handleRecursive:
     e
 
   def apply(op: String, details: => String, exc: Throwable, weight: Int = 1)(using Context): Nothing =
-    if ctx.settings.XnoDecodeStacktraces.value then
+    if ctx.settings.XnoEnrichErrorMessages.value then
       throw exc
     else exc match
       case _: RecursionOverflow =>
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 7fd6444746ce..4cc67bee224c 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -392,7 +392,7 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) {
         }
       catch
         case ex: Throwable =>
-          if !ctx.settings.XnoDecodeStacktraces.value
+          if !ctx.settings.XnoEnrichErrorMessages.value
             && handleRecursive.underlyingStackOverflowOrNull(ex) != null then
             throw StackSizeExceeded(mdef)
           else

From e926badd7e7c9d5cf5473559769ad8dce0302c55 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 14 Dec 2024 18:09:18 +0100
Subject: [PATCH 292/306] Update Maintenance.md

New: Anna Herlihy for named tuples
---
 MAINTENANCE.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/MAINTENANCE.md b/MAINTENANCE.md
index 05b90cc90b86..47339e17eee5 100644
--- a/MAINTENANCE.md
+++ b/MAINTENANCE.md
@@ -69,7 +69,7 @@ The following is the list of all the principal areas of the compiler and the int
 - Parser: @odersky, @hamzaremmal, @KacperFKorban
 - Typer: @odersky, @smarter, (@dwijnand), @noti0nal, @EugeneFlesselle, @KacperFKorban, @bracevac
 - Erasure: @smarter, @odersky
-- Enums: 
+- Enums:
 - Derivation & Mirrors: (@dwijnand), @EugeneFlesselle
 - Export: @odersky
 - Pattern Matching: @dwijnand, @sjrd, @noti0na1
@@ -77,7 +77,7 @@ The following is the list of all the principal areas of the compiler and the int
 - Metaprogramming (Quotes, Reflect, Staging): @jchyb, @hamzaremmal
 - Match types: @sjrd, @dwijnand, @Linyxus, @EugeneFlesselle
 - GADT: @dwijnand, @Linyxus
-- Initialization checker: 
+- Initialization checker:
 - Transforms: @sjrd, @odersky, @smarter
 - Tailrec: @sjrd, @mbovel
 - JS backend: @sjrd
@@ -87,7 +87,7 @@ The following is the list of all the principal areas of the compiler and the int
 - Safe nulls (experimental): @noti0na1
 - Capture checker (experimental): @odersky, @Linyxus, @bracevac, @noti0na1
 - Modularity (experimental): @KacperFKorban
-- Named Tuples (experimental): @odersky
+- Named Tuples (experimental): @odersky, @aherlihy
 
 ### Tooling
 - REPL: @dwijnand
@@ -95,9 +95,9 @@ The following is the list of all the principal areas of the compiler and the int
 - IDE: @tgodzik, (@kasiaMarek)
 - Scaladoc: @Florian3k
 - SemanticDB: @natsukagami, (@tanishiking)
-- Coverage: @KacperFKorban 
+- Coverage: @KacperFKorban
 - Linting (especially unused warnings) / Reporting UX: @KacperFKorban
-- Presentation Compiler: @rochala, @tgodzik, @kasiaMarek, @natsukagami 
+- Presentation Compiler: @rochala, @tgodzik, @kasiaMarek, @natsukagami
 - Debug Adapter: @adpi2, (@tgodzik)
 - Scastie: @rochala
 

From 9d36dd19666259e1a060358d42f5b1ee1119884e Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 14 Dec 2024 19:44:51 +0100
Subject: [PATCH 293/306] Fix ScalaSettingsTest

---
 compiler/src/dotty/tools/dotc/config/ScalaSettings.scala    | 2 +-
 .../test/dotty/tools/dotc/config/ScalaSettingsTests.scala   | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
index 0cec6aeaa661..6a8a88a429e5 100644
--- a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
+++ b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
@@ -486,7 +486,7 @@ private sealed trait YSettings:
   @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.5.0")
   val YreadComments: Setting[Boolean] = BooleanSetting(ForkSetting, "Yread-docs", "Read documentation from tasty.", deprecation = Deprecation.renamed("-Xread-docs"))
   @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.5.0")
-  val YnoDecodeStacktraces: Setting[Boolean] = BooleanSetting(ForkSetting, "Yno-decode-stacktraces", "Show raw StackOverflow stacktraces, instead of decoding them into triggering operations.", deprecation = Deprecation.renamed("-Xno-decode-stacktraces"))
+  val YnoDecodeStacktraces: Setting[Boolean] = BooleanSetting(ForkSetting, "Yno-decode-stacktraces", "Show raw StackOverflow stacktraces, instead of decoding them into triggering operations.", deprecation = Deprecation.renamed("-Xno-enrich-error-messages"))
   @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.5.0")
   val YnoEnrichErrorMessages: Setting[Boolean] = BooleanSetting(ForkSetting, "Yno-enrich-error-messages", "Show raw error messages, instead of enriching them with contextual information.", deprecation = Deprecation.renamed("-Xno-enrich-error-messages"))
   @deprecated(message = "Lifted to -X, Scheduled for removal.", since = "3.5.0")
diff --git a/compiler/test/dotty/tools/dotc/config/ScalaSettingsTests.scala b/compiler/test/dotty/tools/dotc/config/ScalaSettingsTests.scala
index a412848eaa98..07834684d33b 100644
--- a/compiler/test/dotty/tools/dotc/config/ScalaSettingsTests.scala
+++ b/compiler/test/dotty/tools/dotc/config/ScalaSettingsTests.scala
@@ -105,7 +105,7 @@ class ScalaSettingsTests:
       createTestCase(settings.YdropComments         , settings.XdropComments),
       createTestCase(settings.YcookComments         , settings.XcookComments),
       createTestCase(settings.YreadComments         , settings.XreadComments),
-      createTestCase(settings.YnoDecodeStacktraces  , settings.XnoDecodeStacktraces),
+      createTestCase(settings.YnoDecodeStacktraces  , settings.XnoEnrichErrorMessages),
       createTestCase(settings.YnoEnrichErrorMessages, settings.XnoEnrichErrorMessages),
       createTestCase(settings.YdebugMacros          , settings.XdebugMacros),
       // createTestCase(settings.YjavaTasty            , settings.XjavaTasty),
@@ -134,7 +134,7 @@ class ScalaSettingsTests:
       createTestCase(settings.YdropComments         , settings.XdropComments),
       createTestCase(settings.YcookComments         , settings.XcookComments),
       createTestCase(settings.YreadComments         , settings.XreadComments),
-      createTestCase(settings.YnoDecodeStacktraces  , settings.XnoDecodeStacktraces),
+      createTestCase(settings.YnoDecodeStacktraces  , settings.XnoEnrichErrorMessages),
       createTestCase(settings.YnoEnrichErrorMessages, settings.XnoEnrichErrorMessages),
       createTestCase(settings.YdebugMacros          , settings.XdebugMacros),
       // createTestCase(settings.YjavaTasty            , settings.XjavaTasty),
@@ -175,7 +175,7 @@ class ScalaSettingsTests:
       createTestCase(settings.YdropComments         , settings.XdropComments),
       createTestCase(settings.YcookComments         , settings.XcookComments),
       createTestCase(settings.YreadComments         , settings.XreadComments),
-      createTestCase(settings.YnoDecodeStacktraces  , settings.XnoDecodeStacktraces),
+      createTestCase(settings.YnoDecodeStacktraces  , settings.XnoEnrichErrorMessages),
       createTestCase(settings.YnoEnrichErrorMessages, settings.XnoEnrichErrorMessages),
       createTestCase(settings.YdebugMacros          , settings.XdebugMacros),
       // createTestCase(settings.YjavaTasty            , settings.XjavaTasty),

From da176c326fbad4468a7acdcc6fb5df2a80f0c46b Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Mon, 16 Dec 2024 11:59:46 +0100
Subject: [PATCH 294/306] Only count associated files of direct members of
 package objects in dropStale (#22190)

possible fix for #17394
---
 compiler/src/dotty/tools/dotc/core/SymDenotations.scala | 4 +++-
 tests/pos/i17394/_1.scala                               | 9 +++++++++
 tests/pos/i17394/_2.scala                               | 4 ++++
 tests/pos/i17394b/_1.scala                              | 9 +++++++++
 tests/pos/i17394b/_2.scala                              | 5 +++++
 5 files changed, 30 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i17394/_1.scala
 create mode 100644 tests/pos/i17394/_2.scala
 create mode 100644 tests/pos/i17394b/_1.scala
 create mode 100644 tests/pos/i17394b/_2.scala

diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index e14e5cf0a728..be651842d9b0 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -2539,7 +2539,9 @@ object SymDenotations {
           )
         if compiledNow.exists then compiledNow
         else
-          val assocFiles = multi.aggregate(d => Set(d.symbol.associatedFile.nn), _ union _)
+          val assocFiles = multi
+            .filterWithPredicate(_.symbol.maybeOwner.isPackageObject)
+            .aggregate(d => Set(d.symbol.associatedFile.nn), _ union _)
           if assocFiles.size == 1 then
             multi // they are all overloaded variants from the same file
           else
diff --git a/tests/pos/i17394/_1.scala b/tests/pos/i17394/_1.scala
new file mode 100644
index 000000000000..fdab17ec3f19
--- /dev/null
+++ b/tests/pos/i17394/_1.scala
@@ -0,0 +1,9 @@
+package example:
+  def xd: Int = ???
+
+package bar:
+  trait A:
+    def foo: String = ???
+
+package object example extends bar.A:
+  def foo(x: String): String = ???
diff --git a/tests/pos/i17394/_2.scala b/tests/pos/i17394/_2.scala
new file mode 100644
index 000000000000..5ac6a31a66b2
--- /dev/null
+++ b/tests/pos/i17394/_2.scala
@@ -0,0 +1,4 @@
+import example.*
+
+@main def main =
+  val _ = foo
diff --git a/tests/pos/i17394b/_1.scala b/tests/pos/i17394b/_1.scala
new file mode 100644
index 000000000000..fdab17ec3f19
--- /dev/null
+++ b/tests/pos/i17394b/_1.scala
@@ -0,0 +1,9 @@
+package example:
+  def xd: Int = ???
+
+package bar:
+  trait A:
+    def foo: String = ???
+
+package object example extends bar.A:
+  def foo(x: String): String = ???
diff --git a/tests/pos/i17394b/_2.scala b/tests/pos/i17394b/_2.scala
new file mode 100644
index 000000000000..8c86ca45e215
--- /dev/null
+++ b/tests/pos/i17394b/_2.scala
@@ -0,0 +1,5 @@
+//> using options -Wunused:imports
+
+import example.{given, *}
+
+@main def main = ()

From ecccfc9631a97c94a0c23e7beab181ff84462a7c Mon Sep 17 00:00:00 2001
From: Yichen Xu <yichen.x@outlook.com>
Date: Mon, 16 Dec 2024 14:04:38 +0000
Subject: [PATCH 295/306] Add hint when found cc language import in repl

---
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 89f88faebc17..8e5de37a4e20 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -3706,7 +3706,11 @@ object Parsers {
           in.languageImportContext = in.languageImportContext.importContext(imp, NoSymbol)
           for case ImportSelector(id @ Ident(imported), EmptyTree, _) <- selectors do
             if Feature.handleGlobalLanguageImport(prefix, imported) && !outermost then
-              syntaxError(em"this language import is only allowed at the toplevel", id.span)
+              val hint =
+                if ctx.mode.is(Mode.Interactive) then
+                  f"\nTo use this language feature, include the flag `-language:$prefix.$imported` when starting the REPL"
+                else ""
+              syntaxError(em"this language import is only allowed at the toplevel$hint", id.span)
             if allSourceVersionNames.contains(imported) && prefix.isEmpty then
               if !outermost then
                 syntaxError(em"source version import is only allowed at the toplevel", id.span)

From 958371ccb20ad55612d241f71a43e3063dec6328 Mon Sep 17 00:00:00 2001
From: Yichen Xu <yichen.x@outlook.com>
Date: Mon, 16 Dec 2024 14:06:00 +0000
Subject: [PATCH 296/306] Refine the hint

---
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 8e5de37a4e20..eb277edcfbce 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -3706,11 +3706,15 @@ object Parsers {
           in.languageImportContext = in.languageImportContext.importContext(imp, NoSymbol)
           for case ImportSelector(id @ Ident(imported), EmptyTree, _) <- selectors do
             if Feature.handleGlobalLanguageImport(prefix, imported) && !outermost then
+              val location =
+                if ctx.mode.is(Mode.Interactive) then
+                  "in the REPL"
+                else "at the toplevel"
               val hint =
                 if ctx.mode.is(Mode.Interactive) then
                   f"\nTo use this language feature, include the flag `-language:$prefix.$imported` when starting the REPL"
                 else ""
-              syntaxError(em"this language import is only allowed at the toplevel$hint", id.span)
+              syntaxError(em"this language import is only allowed $location$hint", id.span)
             if allSourceVersionNames.contains(imported) && prefix.isEmpty then
               if !outermost then
                 syntaxError(em"source version import is only allowed at the toplevel", id.span)

From 45f0d60e997b8553d56d52367469464d9769f398 Mon Sep 17 00:00:00 2001
From: Seth Tisue <seth@tisue.net>
Date: Thu, 12 Dec 2024 14:31:45 -0800
Subject: [PATCH 297/306] in CI, use new standard scala/cla-checker action

---
 .github/PULL_REQUEST_TEMPLATE/fix-issue.md |  2 +-
 .github/PULL_REQUEST_TEMPLATE/other-pr.md  |  2 +-
 .github/workflows/cla.yml                  | 17 ++++-------------
 docs/_docs/contributing/getting-started.md |  2 +-
 project/scripts/check-cla.sh               | 20 --------------------
 5 files changed, 7 insertions(+), 36 deletions(-)
 delete mode 100755 project/scripts/check-cla.sh

diff --git a/.github/PULL_REQUEST_TEMPLATE/fix-issue.md b/.github/PULL_REQUEST_TEMPLATE/fix-issue.md
index f7cf22eb59c7..005be5daef4f 100644
--- a/.github/PULL_REQUEST_TEMPLATE/fix-issue.md
+++ b/.github/PULL_REQUEST_TEMPLATE/fix-issue.md
@@ -8,7 +8,7 @@ assignees: ''
 
 <!--
   TODO first sign the CLA
-  https://www.lightbend.com/contribute/cla/scala
+  https://contribute.akka.io/cla/scala
 -->
 
 ## Fix #XYZ
diff --git a/.github/PULL_REQUEST_TEMPLATE/other-pr.md b/.github/PULL_REQUEST_TEMPLATE/other-pr.md
index fad49836df92..a9948b717932 100644
--- a/.github/PULL_REQUEST_TEMPLATE/other-pr.md
+++ b/.github/PULL_REQUEST_TEMPLATE/other-pr.md
@@ -8,7 +8,7 @@ assignees: ''
 
 <!--
   TODO first sign the CLA
-  https://www.lightbend.com/contribute/cla/scala
+  https://contribute.akka.io/cla/scala
 -->
 
 ## Description
diff --git a/.github/workflows/cla.yml b/.github/workflows/cla.yml
index f370cb2b541c..d052dc5eb6fc 100644
--- a/.github/workflows/cla.yml
+++ b/.github/workflows/cla.yml
@@ -3,20 +3,11 @@ on:
   pull_request:
     branches-ignore:
       - 'language-reference-stable'
-  push:
-    branches:
-      - 'language-reference-stable'
-  merge_group:
-permissions:
-  contents: write
-  pull-requests: write
-
 jobs:
   check:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
-    - run: ./project/scripts/check-cla.sh
-      if: github.event_name == 'pull_request'
-      env:
-        AUTHOR: ${{ github.event.pull_request.user.login }}
+      - name: Verify CLA
+        uses: scala/cla-checker@v1
+        with:
+          author: ${{ github.event.pull_request.user.login }}
diff --git a/docs/_docs/contributing/getting-started.md b/docs/_docs/contributing/getting-started.md
index b6e3e4fac00a..c660edb2400e 100644
--- a/docs/_docs/contributing/getting-started.md
+++ b/docs/_docs/contributing/getting-started.md
@@ -146,6 +146,6 @@ The main development discussion channels are:
 [java11]: https://www.oracle.com/java/technologies/javase-jdk11-downloads.html
 [adopt]: https://adoptopenjdk.net/
 [compat]: https://docs.scala-lang.org/overviews/jdk-compatibility/overview.html
-[scala-cla]: https://www.lightbend.com/contribute/cla/scala
+[scala-cla]: https://contribute.akka.io/cla/scala
 [dotty-issue]: https://github.com/scala/scala3/issues
 [dotty-discussion]: https://github.com/scala/scala3/discussions
diff --git a/project/scripts/check-cla.sh b/project/scripts/check-cla.sh
deleted file mode 100755
index dbb148d3c652..000000000000
--- a/project/scripts/check-cla.sh
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/usr/bin/env bash
-set -eux
-
-echo "Pull request submitted by $AUTHOR";
-if [[ "$AUTHOR" == "github-actions[bot]" || "$AUTHOR" == "dependabot[bot]" ]] ; then
-  echo "CLA check for $AUTHOR successful";
-else
-  signed=$(curl -L -s "https://contribute.akka.io/contribute/cla/scala/check/$AUTHOR" | jq -r ".signed");
-  if [ "$signed" = "true" ] ; then
-    echo "CLA check for $AUTHOR successful";
-  else
-    echo "CLA check for $AUTHOR failed";
-    echo "Please sign the Scala CLA to contribute to the Scala compiler.";
-    echo "Go to https://contribute.akka.io/contribute/cla/scala and then";
-    echo "comment on the pull request to ask for a new check.";
-    echo "";
-    echo "Check if CLA is signed: https://contribute.akka.io/contribute/cla/scala/check/$AUTHOR";
-    exit 1;
-  fi;
-fi;

From 09375635d2869063f88cb28ec47b16284ac35d6d Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 16 Dec 2024 13:31:12 +0100
Subject: [PATCH 298/306] Also perform change in error messages

---
 compiler/src/dotty/tools/dotc/core/TypeErrors.scala        | 2 +-
 compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala | 2 +-
 tests/neg/i2887b.check                                     | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala b/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
index 40927dd3f40f..8630ea4fc822 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
@@ -117,7 +117,7 @@ extends TypeError:
     em"""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 -Xno-decode-stacktraces.
+        |For the unprocessed stack trace, compile with Xno-enrich-error-messages.
         |A recurring operation is (inner to outer):
         |${opsString(mostCommon).stripMargin}"""
 
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 4cc67bee224c..7b80c7c80a21 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -941,7 +941,7 @@ class TreePickler(pickler: TastyPickler, attributes: Attributes) {
           em"""Recursion limit exceeded while pickling ${ex.mdef}
               |in ${ex.mdef.symbol.showLocated}.
               |You could try to increase the stacksize using the -Xss JVM option.
-              |For the unprocessed stack trace, compile with -Xno-decode-stacktraces.""",
+              |For the unprocessed stack trace, compile with -Xno-enrich-error-messages.""",
           ex.mdef.srcPos)
 
     def missing = forwardSymRefs.keysIterator
diff --git a/tests/neg/i2887b.check b/tests/neg/i2887b.check
index 5bd5f570fbf7..578fe3db573f 100644
--- a/tests/neg/i2887b.check
+++ b/tests/neg/i2887b.check
@@ -4,7 +4,7 @@
    |       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 -Xno-decode-stacktraces.
+   |       For the unprocessed stack trace, compile with Xno-enrich-error-messages.
    |       A recurring operation is (inner to outer):
    |
    |         try to instantiate Z[Z]

From 2e409e1f50796e2e869c32f4f551f4d0d7a97115 Mon Sep 17 00:00:00 2001
From: Yichen Xu <yichen.x@outlook.com>
Date: Mon, 16 Dec 2024 21:09:24 +0100
Subject: [PATCH 299/306] Fix the description

---
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index eb277edcfbce..e9f6b01a99c3 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -3706,15 +3706,15 @@ object Parsers {
           in.languageImportContext = in.languageImportContext.importContext(imp, NoSymbol)
           for case ImportSelector(id @ Ident(imported), EmptyTree, _) <- selectors do
             if Feature.handleGlobalLanguageImport(prefix, imported) && !outermost then
-              val location =
+              val desc =
                 if ctx.mode.is(Mode.Interactive) then
-                  "in the REPL"
-                else "at the toplevel"
+                  "not allowed in the REPL"
+                else "only allowed at the toplevel"
               val hint =
                 if ctx.mode.is(Mode.Interactive) then
                   f"\nTo use this language feature, include the flag `-language:$prefix.$imported` when starting the REPL"
                 else ""
-              syntaxError(em"this language import is only allowed $location$hint", id.span)
+              syntaxError(em"this language import is $desc$hint", id.span)
             if allSourceVersionNames.contains(imported) && prefix.isEmpty then
               if !outermost then
                 syntaxError(em"source version import is only allowed at the toplevel", id.span)

From c79b2121bf11ffc2f8b668299c658bb2983bc55a Mon Sep 17 00:00:00 2001
From: Yichen Xu <yichen.x@outlook.com>
Date: Mon, 16 Dec 2024 21:09:35 +0100
Subject: [PATCH 300/306] Add repl tests

---
 .../dotty/tools/repl/ReplCompilerTests.scala   | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/compiler/test/dotty/tools/repl/ReplCompilerTests.scala b/compiler/test/dotty/tools/repl/ReplCompilerTests.scala
index 221eb8acb9de..d32b28647c32 100644
--- a/compiler/test/dotty/tools/repl/ReplCompilerTests.scala
+++ b/compiler/test/dotty/tools/repl/ReplCompilerTests.scala
@@ -493,6 +493,24 @@ class ReplCompilerTests extends ReplTest:
     assertTrue(all.head.startsWith("-- [E103] Syntax Error"))
     assertTrue(all.exists(_.trim().startsWith("|  Illegal start of statement: this modifier is not allowed here")))
 
+  @Test def `i16250a`: Unit = initially:
+    val hints = List(
+      "this language import is not allowed in the REPL",
+      "To use this language feature, include the flag `-language:experimental.captureChecking` when starting the REPL"
+    )
+    run("import language.experimental.captureChecking")
+    val all = lines()
+    assertTrue(hints.forall(hint => all.exists(_.contains(hint))))
+
+  @Test def `i16250b`: Unit = initially:
+    val hints = List(
+      "this language import is not allowed in the REPL",
+      "To use this language feature, include the flag `-language:experimental.pureFunctions` when starting the REPL"
+    )
+    run("import language.experimental.pureFunctions")
+    val all = lines()
+    assertTrue(hints.forall(hint => all.exists(_.contains(hint))))
+
 object ReplCompilerTests:
 
   private val pattern = Pattern.compile("\\r[\\n]?|\\n");

From 8b7c98c5da12d68af82ef0df5f5da781b78102a7 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 16 Dec 2024 23:22:15 +0100
Subject: [PATCH 301/306] Fix typo

---
 compiler/src/dotty/tools/dotc/core/TypeErrors.scala | 2 +-
 tests/neg/i2887b.check                              | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala b/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
index 8630ea4fc822..4761beae8bd0 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
@@ -117,7 +117,7 @@ extends TypeError:
     em"""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 Xno-enrich-error-messages.
+        |For the unprocessed stack trace, compile with -Xno-enrich-error-messages.
         |A recurring operation is (inner to outer):
         |${opsString(mostCommon).stripMargin}"""
 
diff --git a/tests/neg/i2887b.check b/tests/neg/i2887b.check
index 578fe3db573f..eb89f8582e5a 100644
--- a/tests/neg/i2887b.check
+++ b/tests/neg/i2887b.check
@@ -4,7 +4,7 @@
    |       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 Xno-enrich-error-messages.
+   |       For the unprocessed stack trace, compile with -Xno-enrich-error-messages.
    |       A recurring operation is (inner to outer):
    |
    |         try to instantiate Z[Z]

From 4961d1eaf219cbf920206ba1e15101a7cdc94eef Mon Sep 17 00:00:00 2001
From: Hamza Remmal <hamza@remmal.dev>
Date: Tue, 17 Dec 2024 13:12:35 +0100
Subject: [PATCH 302/306] chore: use sbt/setup-sbt when using ubuntu-latest
 image

---
 .github/workflows/build-sdk.yml           |  1 +
 .github/workflows/language-reference.yaml |  1 +
 .github/workflows/launchers.yml           | 14 +++++---------
 .github/workflows/scaladoc.yaml           |  1 +
 .github/workflows/test-cc.yml             |  1 +
 5 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/build-sdk.yml b/.github/workflows/build-sdk.yml
index b2af623d731a..cd111df1a083 100644
--- a/.github/workflows/build-sdk.yml
+++ b/.github/workflows/build-sdk.yml
@@ -61,6 +61,7 @@ jobs:
           distribution: temurin
           java-version: ${{ inputs.java-version }}
           cache       : sbt
+      - uses: sbt/setup-sbt@v1
       - name: Build and pack the SDK (universal)
         run : ./project/scripts/sbt dist/Universal/stage
       - name: Build and pack the SDK (linux x86-64)
diff --git a/.github/workflows/language-reference.yaml b/.github/workflows/language-reference.yaml
index 7f87b4a453ef..d79f4d029a77 100644
--- a/.github/workflows/language-reference.yaml
+++ b/.github/workflows/language-reference.yaml
@@ -36,6 +36,7 @@ jobs:
           distribution: 'temurin'
           java-version: 17
           cache: 'sbt'
+      - uses: sbt/setup-sbt@v1
 
       - name: Generate reference documentation and test links
         run: |
diff --git a/.github/workflows/launchers.yml b/.github/workflows/launchers.yml
index ce3aac235224..4ee07e4bfcc9 100644
--- a/.github/workflows/launchers.yml
+++ b/.github/workflows/launchers.yml
@@ -20,6 +20,7 @@ jobs:
           java-version: '17'
           distribution: 'temurin'
           cache: 'sbt'
+      - uses: sbt/setup-sbt@v1
       - name: Build and test launcher command
         run: ./project/scripts/native-integration/bashTests
         env:
@@ -37,9 +38,7 @@ jobs:
           java-version: '17'
           distribution: 'temurin'
           cache: 'sbt'
-      # https://github.com/actions/runner-images/issues/9369
-      - name: Install sbt
-        run: brew install sbt
+      - uses: sbt/setup-sbt@v1
       - name: Build and test launcher command
         run: ./project/scripts/native-integration/bashTests
         env:
@@ -58,9 +57,7 @@ jobs:
           java-version: '17'
           distribution: 'temurin'
           cache: 'sbt'
-      # https://github.com/actions/runner-images/issues/9369
-      - name: Install sbt
-        run: brew install sbt
+      - uses: sbt/setup-sbt@v1
       - name: Build and test launcher command
         run: ./project/scripts/native-integration/bashTests
         env:
@@ -79,9 +76,7 @@ jobs:
           java-version: '17'
           distribution: 'temurin'
           cache: 'sbt'
-      # https://github.com/actions/runner-images/issues/9369
-      - name: Install sbt
-        run: brew install sbt
+      - uses: sbt/setup-sbt@v1
       - name: Build and test launcher command
         run: ./project/scripts/native-integration/bashTests
         env:
@@ -100,6 +95,7 @@ jobs:
           java-version: '17'
           distribution: 'temurin'
           cache: 'sbt'
+      - uses: sbt/setup-sbt@v1
       - name: Build the launcher command
         run: sbt "dist-win-x86_64/Universal/stage"
       - name: Run the launcher command tests
diff --git a/.github/workflows/scaladoc.yaml b/.github/workflows/scaladoc.yaml
index 4f6f5bbfe2fb..d2e3071e765b 100644
--- a/.github/workflows/scaladoc.yaml
+++ b/.github/workflows/scaladoc.yaml
@@ -37,6 +37,7 @@ jobs:
           java-version: 17
           cache: 'sbt'
 
+      - uses: sbt/setup-sbt@v1
       - name: Compile and test scala3doc-js
         run: ./project/scripts/sbt scaladoc-js-main/test
 
diff --git a/.github/workflows/test-cc.yml b/.github/workflows/test-cc.yml
index 39d21b5b952f..973323f49703 100644
--- a/.github/workflows/test-cc.yml
+++ b/.github/workflows/test-cc.yml
@@ -22,5 +22,6 @@ jobs:
     steps:
       - name: Git Checkout
         uses: actions/checkout@v4
+      - uses: sbt/setup-sbt@v1
       - name: Test with Scala 2 library with CC TASTy
         run: ./project/scripts/sbt ";set ThisBuild/Build.scala2Library := Build.Scala2LibraryCCTasty ;scala3-bootstrapped/test"

From 72848b3576e94a5092a6927ee0ec450d15e6621d Mon Sep 17 00:00:00 2001
From: Hamza Remmal <hamza@remmal.dev>
Date: Tue, 17 Dec 2024 15:56:30 +0100
Subject: [PATCH 303/306] fix: add sbt/setup-sbt for the dependency graph
 workflow

---
 .github/workflows/dependency-graph.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/dependency-graph.yml b/.github/workflows/dependency-graph.yml
index 35af4fa0526d..6a3f8174b2d7 100644
--- a/.github/workflows/dependency-graph.yml
+++ b/.github/workflows/dependency-graph.yml
@@ -9,6 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+      - uses: sbt/setup-sbt@v1
       - uses: scalacenter/sbt-dependency-submission@v3
         env:
           DEVELOCITY_ACCESS_KEY: ${{ secrets.DEVELOCITY_ACCESS_KEY }}

From 80d00f3f0f687bb0a6977c28d5f3f429de0d7b3f Mon Sep 17 00:00:00 2001
From: xuwei-k <6b656e6a69@gmail.com>
Date: Wed, 18 Dec 2024 07:18:47 +0900
Subject: [PATCH 304/306] replace deprecated AnyRefMap

---
 .../src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala |  2 +-
 .../tools/dotc/classpath/DirectoryClassPath.scala      |  2 +-
 .../dotty/tools/dotc/core/tasty/TreeUnpickler.scala    |  2 +-
 .../dotc/core/unpickleScala2/Scala2Unpickler.scala     |  2 +-
 compiler/src/dotty/tools/dotc/typer/Namer.scala        | 10 +++++-----
 .../src/dotty/tools/dotc/util/FreshNameCreator.scala   |  2 +-
 library/src/scala/runtime/coverage/Invoker.scala       |  6 +++---
 7 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala b/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
index 4f4caf36d92a..e632def24700 100644
--- a/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
+++ b/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
@@ -515,7 +515,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
      */
     object locals {
 
-      private val slots = mutable.AnyRefMap.empty[Symbol, Local] // (local-or-param-sym -> Local(BType, name, idx, isSynth))
+      private val slots = mutable.HashMap.empty[Symbol, Local] // (local-or-param-sym -> Local(BType, name, idx, isSynth))
 
       private var nxtIdx = -1 // next available index for local-var
 
diff --git a/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala b/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala
index aed5be45cb0d..2d659b532d7b 100644
--- a/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala
+++ b/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala
@@ -229,7 +229,7 @@ final class CtSymClassPath(ctSym: java.nio.file.Path, release: Int) extends Clas
 
   // 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 index = collection.mutable.HashMap[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
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index de99ce0105ea..d9ae4ddb6006 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1432,7 +1432,7 @@ class TreeUnpickler(reader: TastyReader,
                 extendOnly(namedArgs)
               else
                 // needs reordering, and possibly fill in holes for default arguments
-                val argsByName = mutable.AnyRefMap.from(namedArgs.map(arg => arg.name -> arg))
+                val argsByName = mutable.HashMap.from(namedArgs.map(arg => arg.name -> arg))
                 val reconstructedArgs = formalNames.lazyZip(methType.paramInfos).map { (name, tpe) =>
                   argsByName.remove(name).getOrElse(makeDefault(name, tpe))
                 }
diff --git a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
index 611fda9c1d41..3b91312740d1 100644
--- a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
@@ -161,7 +161,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
   private val entries = new Array[AnyRef](index.length)
 
   /** A map from symbols to their associated `decls` scopes */
-  private val symScopes = mutable.AnyRefMap[Symbol, Scope]()
+  private val symScopes = mutable.HashMap[Symbol, Scope]()
 
   /** A mapping from method types to the parameters used in constructing them */
   private val paramsOfMethodType = new java.util.IdentityHashMap[MethodType, List[Symbol]]
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 87dec93f8040..eaf7380ef5c7 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -66,9 +66,9 @@ class Namer { typer: Typer =>
   /** 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]
+  //lazy val expandedTree = new mutable.HashMap[DefTree, Tree]
   /*{
-    override def default(tree: DefTree) = tree // can't have defaults on AnyRefMaps :-(
+    override def default(tree: DefTree) = tree // can't have defaults on HashMaps :-(
   }*/
 
   /** A map from expanded MemberDef, PatDef or Import trees to their symbols.
@@ -76,12 +76,12 @@ class Namer { typer: Typer =>
    *  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]
+  //lazy val symOfTree = new mutable.HashMap[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]
+  // lazy val typedTree = new mutable.HashMap[Tree, tpd.Tree]
 
   /** A map from method symbols to nested typers.
    *  Populated when methods are completed. Emptied when they are typechecked.
@@ -89,7 +89,7 @@ class Namer { typer: Typer =>
    *  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
+  lazy val nestedTyper: mutable.HashMap[Symbol, Typer] = new mutable.HashMap
 
   /** We are entering symbols coming from a SourceLoader */
   private var lateCompile = false
diff --git a/compiler/src/dotty/tools/dotc/util/FreshNameCreator.scala b/compiler/src/dotty/tools/dotc/util/FreshNameCreator.scala
index f3375028c95f..f95b4bf85a96 100644
--- a/compiler/src/dotty/tools/dotc/util/FreshNameCreator.scala
+++ b/compiler/src/dotty/tools/dotc/util/FreshNameCreator.scala
@@ -14,7 +14,7 @@ abstract class FreshNameCreator {
 object FreshNameCreator {
   class Default extends FreshNameCreator {
     protected var counter: Int = 0
-    protected val counters: mutable.Map[String, Int] = mutable.AnyRefMap() withDefaultValue 0
+    protected val counters: mutable.Map[String, Int] = mutable.HashMap() withDefaultValue 0
 
     /**
      * Create a fresh name with the given prefix. It is guaranteed
diff --git a/library/src/scala/runtime/coverage/Invoker.scala b/library/src/scala/runtime/coverage/Invoker.scala
index c35c6c2ec7df..b3216ec37c67 100644
--- a/library/src/scala/runtime/coverage/Invoker.scala
+++ b/library/src/scala/runtime/coverage/Invoker.scala
@@ -3,7 +3,7 @@ package scala.runtime.coverage
 import scala.annotation.internal.sharable
 import scala.annotation.nowarn
 import scala.collection.concurrent.TrieMap
-import scala.collection.mutable.{BitSet, AnyRefMap}
+import scala.collection.mutable.{BitSet, HashMap}
 import java.io.{File, FileWriter}
 import java.nio.file.Files
 
@@ -12,7 +12,7 @@ object Invoker {
   private val runtimeUUID = java.util.UUID.randomUUID()
 
   private val MeasurementsPrefix = "scoverage.measurements."
-  private val threadFiles = new ThreadLocal[AnyRefMap[String, FileWriter]]
+  private val threadFiles = new ThreadLocal[HashMap[String, FileWriter]]
   private val dataDirToSet = TrieMap.empty[String, BitSet]
 
   /** We record that the given id has been invoked by appending its id to the coverage data file.
@@ -38,7 +38,7 @@ object Invoker {
       if added then
         var writers = threadFiles.get()
         if writers == null then
-          writers = AnyRefMap.empty
+          writers = HashMap.empty
           threadFiles.set(writers)
         val writer = writers.getOrElseUpdate(
           dataDir,

From 54312c68e6dbd7335648d06357104a780fb78bf8 Mon Sep 17 00:00:00 2001
From: Hamza Remmal <hamza@remmal.dev>
Date: Wed, 18 Dec 2024 11:18:42 +0100
Subject: [PATCH 305/306] fix: better error messages when an enum derives from
 AnyVal

---
 .../src/dotty/tools/dotc/reporting/ErrorMessageID.scala    | 1 +
 compiler/src/dotty/tools/dotc/reporting/messages.scala     | 6 ++++++
 compiler/src/dotty/tools/dotc/typer/Checking.scala         | 7 ++++++-
 compiler/src/dotty/tools/dotc/typer/Namer.scala            | 3 ++-
 tests/neg/i21944.check                                     | 4 ++++
 tests/neg/i21944.scala                                     | 2 ++
 6 files changed, 21 insertions(+), 2 deletions(-)
 create mode 100644 tests/neg/i21944.check
 create mode 100644 tests/neg/i21944.scala

diff --git a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
index d3467fe70c52..cc78203e873f 100644
--- a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
@@ -219,6 +219,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case DeprecatedAssignmentSyntaxID // errorNumber: 203
   case DeprecatedInfixNamedArgumentSyntaxID // errorNumber: 204
   case GivenSearchPriorityID // errorNumber: 205
+  case EnumMayNotBeValueClassesID // errorNumber: 206
 
   def errorNumber = ordinal - 1
 
diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index 75aa553827f2..28a2b5757a93 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -3399,3 +3399,9 @@ class GivenSearchPriorityWarning(
        |$migrationHints"""
 
   def explain(using Context) = ""
+
+final class EnumMayNotBeValueClasses(sym: Symbol)(using Context) extends SyntaxMsg(EnumMayNotBeValueClassesID):
+    def msg(using Context): String = i"$sym may not be a value class"
+
+    def explain(using Context) = ""
+end EnumMayNotBeValueClasses
diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
index 1cd531046753..e870ffd0fc90 100644
--- a/compiler/src/dotty/tools/dotc/typer/Checking.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -734,11 +734,16 @@ object Checking {
       case _ =>
         report.error(ValueClassesMayNotContainInitalization(clazz), stat.srcPos)
     }
-    if (clazz.isDerivedValueClass) {
+    // We don't check synthesised enum anonymous classes that are generated from
+    // enum extending a value class type (AnyVal or an alias of it)
+    // The error message 'EnumMayNotBeValueClassesID' will take care of generating the error message (See #22236)
+    if (clazz.isDerivedValueClass && !clazz.isEnumAnonymClass) {
       if (clazz.is(Trait))
         report.error(CannotExtendAnyVal(clazz), clazz.srcPos)
       if clazz.is(Module) then
         report.error(CannotExtendAnyVal(clazz), clazz.srcPos)
+      if (clazz.is(Enum))
+        report.error(EnumMayNotBeValueClasses(clazz), clazz.srcPos)
       if (clazz.is(Abstract))
         report.error(ValueClassesMayNotBeAbstract(clazz), clazz.srcPos)
       if (!clazz.isStatic)
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 87dec93f8040..e0af9b2d892a 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -1626,7 +1626,8 @@ class Namer { typer: Typer =>
           }
           else {
             val pclazz = pt.typeSymbol
-            if pclazz.is(Final) then
+            // The second condition avoids generating a useless message (See #22236 for more details)
+            if pclazz.is(Final) && !(pclazz.is(Enum) && pclazz.isDerivedValueClass) then
               report.error(ExtendFinalClass(cls, pclazz), cls.srcPos)
             else if pclazz.isEffectivelySealed && pclazz.associatedFile != cls.associatedFile then
               if pclazz.is(Sealed) && !pclazz.is(JavaDefined) then
diff --git a/tests/neg/i21944.check b/tests/neg/i21944.check
new file mode 100644
index 000000000000..591447c6a510
--- /dev/null
+++ b/tests/neg/i21944.check
@@ -0,0 +1,4 @@
+-- [E206] Syntax Error: tests/neg/i21944.scala:1:5 ---------------------------------------------------------------------
+1 |enum Orientation extends AnyVal: // error
+  |     ^
+  |     class Orientation may not be a value class
diff --git a/tests/neg/i21944.scala b/tests/neg/i21944.scala
new file mode 100644
index 000000000000..bf335e56c671
--- /dev/null
+++ b/tests/neg/i21944.scala
@@ -0,0 +1,2 @@
+enum Orientation extends AnyVal: // error
+    case North, South, East, West

From 442e6a09eae30c22aad559ecf520713056e86cec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= <sjrdoeraene@gmail.com>
Date: Wed, 18 Dec 2024 13:52:59 +0100
Subject: [PATCH 306/306] Fix #22226: Use `classOf[BoxedUnit]` for Unit array
 in `ArrayConstructors`.

The `ArrayConstructors` phase rewrites array constructors to calls
to `scala.runtime.Arrays.newArray`. When it does that, it must pass
the run-time `jl.Class` of the element type. Previously, it used
`classOf[Unit]` when creating an `Array[Unit]` (or nested). That
is not correct, as from the Java perspective, we need to create
`Array[BoxedUnit]`.

We now identify `elemType <: Unit` and replace it with `BoxedUnit`.

---

This highlights a limitation of the Scala.js backend. We should
rewrite calls to `newArray` in the backend to use direct array
creation instead.
---
 .../tools/dotc/transform/ArrayConstructors.scala      |  5 ++++-
 .../testsuite/compiler/RegressionTestScala3.scala     | 11 +++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/ArrayConstructors.scala b/compiler/src/dotty/tools/dotc/transform/ArrayConstructors.scala
index e94fa612e6cf..84cb64533532 100644
--- a/compiler/src/dotty/tools/dotc/transform/ArrayConstructors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ArrayConstructors.scala
@@ -27,7 +27,10 @@ class ArrayConstructors extends MiniPhase {
 
   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)))
+      val elemTypeNonVoid =
+        if elemType.isValueSubType(defn.UnitType) then defn.BoxedUnitClass.typeRef
+        else elemType
+      tpd.newArray(elemTypeNonVoid, 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
diff --git a/tests/sjs-junit/test/org/scalajs/testsuite/compiler/RegressionTestScala3.scala b/tests/sjs-junit/test/org/scalajs/testsuite/compiler/RegressionTestScala3.scala
index de260f3481ed..02cb08789232 100644
--- a/tests/sjs-junit/test/org/scalajs/testsuite/compiler/RegressionTestScala3.scala
+++ b/tests/sjs-junit/test/org/scalajs/testsuite/compiler/RegressionTestScala3.scala
@@ -145,6 +145,17 @@ class RegressionTestScala3 {
     assertEquals(5, Issue14289.Container.b())
     assertEquals(true, Issue14289.Container.c())
   }
+
+  @Test def createArrayOfUnitIssue22226(): Unit = {
+    val a = Array.ofDim[Unit](0)
+    assertSame(classOf[Array[Unit]], a.getClass())
+
+    val b = new Array[Unit](0)
+    assertSame(classOf[Array[Unit]], b.getClass())
+
+    val c = Array.ofDim[Unit](0, 0)
+    assertSame(classOf[Array[Array[Unit]]], c.getClass())
+  }
 }
 
 object RegressionTestScala3 {